Building a high performance JSON parser
This talk is a case study of designing an efficient Go package. I’m going to use the example of building a high performance JSON parser. Supports streaming operations It’s unrealistic to expect to have the entire input in memory. Buffering in memory is a availability risk, input sizes are usually unknown and potentially unbounded. Buffering before processing introduces latency. Streaming reads let
How to dump the GOSSAFUNC graph for a method | Dave Cheney
The Go compiler’s SSA backend contains a facility to produce HTML debugging output of the compilation phases. This post covers how to print the SSA output for function and methods. Let’s start with a sample program which contains a function, a value method, and a pointer method: package main import ( "fmt" ) type Numbers struct { vals []int } func (n *Numbers) Add(v int) { n.vals = append(n.vals,
Practical Go | Dave Cheney
A collection of real world advice for writing maintainable Go programs. Presentations QCon Shanghai 2018GopherCon Singapore 2019 Fundamentals What is the zero value, and why is it useful?The empty structOn declaring variablesGo has both make and new functions; what gives?Should methods be declared on T or *T?Slices from the ground upIf a map isn’t a reference, what is it?A variable’s name should b
The Zen of Go | Dave Cheney
This article was derived from my GopherCon Israel 2020 presentation. It’s also quite long. If you’d prefer a shorter version, head over to the-zen-of-go.netlify.com. A recording of the presentation is available on YouTube. How should I write good code? Something that I’ve been thinking about a lot recently, when reflecting on the body of my own work, is a common subtitle, how should I write good c
Go compiler intrinsics | Dave Cheney
Go allows authors to write functions in assembly if required. This is called a stub or forward declaration. package asm // Add returns the sum of a and b. func Add(a int64, b int64) int64 Here we’re declaring Add, a function which takes two int64‘s and returns their sum.Add is a normal Go function declaration, except it is missing the function body. If we were to try to compile this package the co
Constant Time | Dave Cheney
This essay is a derived from my dotGo 2019 presentation about my favourite feature in Go. Many years ago Rob Pike remarked, “Numbers are just numbers, you’ll never see 0x80ULL in a .go source file”. —Rob Pike, The Go Programming Language Beyond this pithy observation lies the fascinating world of Go’s constants. Something that is perhaps taken for granted because, as Rob noted, is Go numbers–const
Taking Go modules for a spin | Dave Cheney
Update: Since this post was written, Go 1.11beta2 has been released. I’ve updated the setup section to reflect this. Russ Cox kindly wrote to me to explain the reasoning behind storing the Go module cache in $GOPATH. I’ve included his response inline. This weekend I wanted to play with Ubuntu 18.04 on a spare machine. This gave me a perfect excuse to try out the modules feature recently merged int
How the Go runtime implements maps efficiently (without generics) | Dave Cheney
This post discusses how maps are implemented in Go. It is based on a presentation I gave at the GoCon Spring 2018 conference in Tokyo, Japan. What is a map function? To understand how a map works, let’s first talk about the idea of the map function. A map function maps one value to another. Given one value, called a key, it will return a second, the value. map(key) → value Now, a map isn’t going t
Go’s hidden #pragmas | Dave Cheney
This is an article about compiler directives; or as they are commonly known, pragmas. It’s derived from a talk of a similar name that I gave last year at GopherChina in Shanghai. But first, a history lesson Before we talk about Go, let’s talk a little about pragmas, and their history. Many languages have the notion of an attribute, or directive, that changes the way source code is interpreted duri
go list, your Swiss army knife | Dave Cheney
During my day job I’ve been working on re-factoring some the internals of Juju to reverse the trend of a growing number of dependencies in our core packages. In this post I’ll show how I used go list to help me in this task. The basics Let’s start with the basics of go list. The default invocation of go list returns the name of the import path that represents the directory you are currently in, or
Context isn’t for cancellation | Dave Cheney
This is an experience report about the use of, and difficulties with, the context.Context facility in Go. Many authors, including myself, have written about the use of, misuse of, and how they would change, context.Context in a future iteration of Go. While opinions differs on many aspects of context.Context, one thing is clear–there is almost unanimous agreement that the Context.WithValue method
How to find out which Go version built your binary | Dave Cheney
This is a short post describing the procedure for discovering which version of Go was used to compile a Go binary. This procedure relies on the fact that each Go program includes a copy of the version string reported by runtime.Version() . Linker magic ensures that this value will be present in the final binary irrespective of whether runtime.Version() is called by the resulting program. The value
Go, without package scoped variables | Dave Cheney
This is a thought experiment, what would Go look like if we could no longer declare variables at the package level? What would be the impact of removing package scoped variable declarations, and what could we learn about the design of Go programs? I’m only talking about expunging var, the other five top level declarations would still be permitted as they are effectively constant at compile time. Y
There is no pass-by-reference in Go | Dave Cheney
My post on pointers provoked a lot of debate about maps and pass by reference semantics. This post is a response to those debates. To be clear, Go does not have reference variables, so Go does not have pass-by-reference function call semantics. What is a reference variable? In languages like C++ you can declare an alias, or an alternate name to an existing variable. This is called a reference vari
The package level logger anti pattern | Dave Cheney
This post is a spin-off from various conversations around improving (I’m trying not to say standardising, otherwise I’ll have to link to XKCD) the way logging is performed in Go projects. Consider this familiar pattern for establishing a package level log variable. package foo import “mylogger” var log = mylogger.GetLogger(“github.com/project/foo”) What’s wrong with this pattern? The first problem
cgo is not Go | Dave Cheney
To steal a quote from JWZ, Some people, when confronted with a problem, think “I know, I’ll use cgo.” Now they have two problems. Recently the use of cgo came up on the Gophers’ slack channel and I voiced my concerns that using cgo, especially on a project that is intended to showcase Go inside an organisation was a bad idea. I’ve said this a number of times, and people are probably sick of hearin
SOLID Go Design | Dave Cheney
This post is based on the text of my GolangUK keynote delivered on the 18th of August 2016. A recording of the talk is available on YouTube. This post has been translated into Simplified Chinese by Haohao Tian. Thanks Haohao! This post has been translated to Russian by Artem Zinoviev. Thanks Artem! How many Go programmers are there in the world? How many Go programmers are there in the world? Thin
Gophers, please tag your releases | Dave Cheney
What do we want? Version management for Go packages! When do we want it? Yesterday! What does everyone want? We want our Go build tool of choice to fetch the latest stable version when you start using the package in your project. We want them to grab security updates and bug fixes automatically, but not upgrade to a version where the author deleted a method you were using. But as it stands, today,
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
https://dave.cheney.net/paste/gopherchina-2019-testing-talk.pdf
Practical Go: Real world advice for writing maintainable Go programs