1
Go 1.7 toolchain improvements
This is a progress report on the Go toolchain improvements during the 1.7 development cycle. All measurements were taken using a Thinkpad x220, Core i5-2520M, running Ubuntu 14.04 linux.
Dave Cheney
Here’s a small quiz derived from some incorrect advice from an AI coding assistant.
- Popular posts
- 34
- Total points
- 6,081
- HN comments
- 3,325
- Rank
- #153 personal
Visit dave.cheney.net → RSS feedOn Hacker News Sep 2012 – Jun 2020
Software Engineering 25Programming Languages 25Systems & Performance 9Career & Management 6History & Retro Computing 2Society, Policy & Culture 1
2
The ‘here is’ key
The Lear Siegler ADM-3A terminal is a very important artefact in computing history.
3
Taking Go modules for a spin
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.
4
Go’s hidden pragmas
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.
5
How the Go runtime implements maps efficiently without generics
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.
6
Understand Go pointers
This post is for programmers coming to Go who are unfamiliar with the idea of pointers or a pointer type in Go.
7
Cross compilation just got better in Go 1.5
Cross compilation is one of Go’s headline features. I’ve written about it a few times , and others have taken this work and built better tooling around it.
8
Go 1.3 Linker Improvements
Go obtains much of its compilation speed from the Plan 9 compiler, of which it is a direct descendant. The Plan 9 toolchain deferred much of the work traditionally performed by a compiler to the linking stage and its performance was summarised in section 8 of this paper
9
Go 1.1 performance improvements
This is the first in a series of articles analysing the performance improvements in the Go 1.1 release.
10
Visualising the Go garbage collector
gcvis is a simple way of visualising the operation of the garbage collector within a Go process. Here is a screenshot of it in operation. The rest of this article explores how gcvis works and how to interpret its results.
11
Go stack traces and the errors package
A few months ago I gave a presentation on my philosophy for error handling . In the talk I introduced a small errors package designed to support the ideas presented in the talk.
12
A whirlwind tour of Go’s runtime environment variables
The Go runtime, in addition to providing the usual services of garbage collection, goroutine scheduling, timers, network polling and so forth, contains facilities to enable extra debugging output and even alter the behaviour of the runtime itself.
13
Things that make Go fast
Anthony Starks has remixed my original Google Present based slides using his fantastic Deck presentation tool. You can check out his remix over on his blog, mindchunk.blogspot.com.au/2014/06/remixing-with-deck .
14
There is no pass by reference in Go
My post on pointers provoked a lot of debate about maps and pass by reference semantics. This post is a response to those debates.
15
Go and Simplicity Debt Redux
In my previous post I discussed my concerns the additional complexity adding generics or immutability would bring to a future Go 2.0. As it was an opinion piece, I tried to keep it around 500 words. This post is an exploration of the most important (and possibly overlooked) point of that post.
16
Another go at the Next Big Language
2007 was a different time for languages. While Java held the popular crown, the mainstream programming community were still coming to terms with Java 6. Released 3 months earlier, it was very much an evolution of the Java 5 watershed. Its arrival heralded the end of life for Java 1.4 and represented an opportunity to…
17
Go’s runtime C to Go rewrite, by the numbers
The start of September brings a close to the Go 1.4 merge window . From now until the release in December, only bug fixes and tweaks will be accepted.
18
Go and Simplicity Debt
Fifteen years ago Python’s GIL wasn’t a big issue. Concurrency was something dismissed as probably unnecessary. What people really was needed was a faster interpreter, after all, who had more than one CPU? But, slowly, as the requirement for concurrency increased, the problems with the GIL increased.
19
Maybe adding generics to Go is about syntax after all
This is a short response to the recently announced Go 2 generics draft proposals
20
How Go uses Go to build itself
This post is based on a talk I gave to the Sydney Go users group in mid April 2013 describing the Go build process.
21
Struct composition with Go
This is a quick Friday blog post to talk about a recent experience I had working on a piece Juju code that needed to capture the data being sent over a net.Conn .
22
Typed nils in Go 2
This is an experience report about a gotcha in Go that catches every Go programmer at least once. The following program is extracted from a larger version that caused my co-workers to lose several hours today.
23
What will be the legacy of Go?
In October this year I had the privilege of speaking at the GothamGo conference in New York City. As I talk quite softly, and there were a few problems with the recording, I decided to write up my slide notes and present them here.
24
Functional options for friendly APIs
What follows is the text of my presentation, Functional options for friendly APIs that I gave at dotGo this year. It has been edited slightly for readability.
25
cgo is not Go
Some people, when confronted with a problem, think “I know, I’ll use cgo.” Now they have two problems.