Go Language Spec —2 min read
Lexical elements: Tokens

Tokens Tokens form the vocabulary of the Go language. There are four classes: identifiers, keywords, operators and punctuation, and literals. White space, formed from spaces (U+0020), horizontal tabs (U+0009), carriage returns (U+000D), and newlines (U+000A), is ignored except as it separates tokens that would otherwise combine into a single token. Also, a newline or end of file may trigger the insertion of a semicolon. While breaking the input into tokens, the next token is the longest sequence of characters that form a valid token.

Go Language Spec —3 min read
Lexical elements: Comments

Let’s talk about comments! This might seem like a pretty dull topic, but there are actually a few nuances in here that even I learned while reading. Lexical elements Comments Comments serve as program documentation. There are two forms: Line comments start with the character sequence // and stop at the end of the line. General comments start with the character sequence \* and stop with the first subsequent character sequence \*.

Go Language Spec —2 min read
Source code representation: Characters, Letters and digits

Today’s section of the Go Spec is pretty straight forward. It defines a few character classes, which are important very quickly when we start talking about names of things (variables, functions, packages, etc) in Go. In fact, this is probably the area of the Go spec that I have referenced most frequently. Any time a question like “Is that a valid variable name?” comes up, you’ll end up referring to this section of the spec.

Go Language Spec —2 min read
Source code representation

Source code representation Source code is Unicode text encoded in UTF-8. The text is not canonicalized, so a single accented code point is distinct from the same character constructed from combining an accent and a letter; those are treated as two code points. For simplicity, this document will use the unqualified term character to refer to a Unicode code point in the source text. Each code point is distinct; for instance, uppercase and lowercase letters are different characters.

Go Language Spec —4 min read

Notation The syntax is specified using a variant of Extended Backus-Naur Form (EBNF): Ah, the good ol’ Extended Backus-Naur Form… EBNF is a fairly popular way to formally describe a formal language. There’s a very good chance you’ve seen something like this before, especially if you’ve ever found yourself reading an RFC. But if you haven’t, this is a great time to familiarize yourself with the basic concepts. I won’t go into a detailed explanation of EBNF or WSN (the variant used in the Go spec), as there are better online resources.

Go Language Spec —3 min read

The Go Programming Language Specification Version of June 29, 2022 The Go Spec gets updated periodically. As of this writing, the latest version was updated June 29, 2022. However, Go 1.20 is scheduled for release in February, and will include some language changes. Throughout this series, I will be referencing the then-current, released version of the spec. And to reduce confusion, I’ll be sure to include the release date of the spec at the bottom of each email.

Go Language Spec —3 min read
Before we start: What is the Go Spec?

It’s a new year. Time for a new daily email list, and a new series! My plan is to spend the next while (a few months, most likely) each day expounding on a small section of the Go Programming Language Specification, or Go Spec for short. But what is a programming language specification, and why should you care about it? In short, it “is a documentation artifact that defines a programming language so that users and implementors can agree on what programs in that language mean.

Code Review —33 min watch
Go Code Roast #2: readability.js port

In this video, I roast a port of a Mozilla Javascript library, readability.js to Go.

JSON —6 min read
JSON Tricks: The Self-Referencing Marshaler

For more content like this, buy my in-progress eBook, Data Serialization in Go⁠, and get updates immediately as they are added! The content in this post is included in my in-progress eBook, Data Serialization in Go, available on LeanPub. I’ve done a lot of JSON handling in Go. In the process, I’ve learned a number of tricks to solve specific problems. But one pattern in particular I find myself repeating ad infinitum.

JSON —5 min read
JSON Tricks: Extending an Embedded Marshaler

How can you embed a struct with a custom MarshalJSON() method?

JSON —6 min read
JSON Tricks: JSON Arrays as Go Structs

How can you marshal and unmarshal JSON array as though it were a struct in Go?