Skip to content #dev

Assertions for Go

Posted November 2017 in #dev

It has long been difficult to write test helpers in Go because you’ve had to keep track of file names and line numbers to exclude helpers from output. This has resulted in some impressive but complicated assertion libraries. Recently, Go 1.9 improved the situation greatly by introducing the Helper method:

The new Helper method, added to both testing.T and testing.B, marks the calling function as a test helper function. When the testing package prints file and line information, it shows the location of the call to a helper function instead of a line in the helper function itself. — The Go Blog

To try this out, I wrote myself a little assertion library. And it’s great! Go can finally have test helpers that tick every box: intuitive signatures, minimal additional complexity, and accurate reporting of file names and line numbers.

package example

import (
	"errors"
	"testing"

	"github.com/olav/wat/is"
)

func TestExample(t *testing.T) {
	is.Equal(t, 1, 1)
	is.Nil(t, nil)
	is.Zero(t, "")
	is.Error(t, errors.New("error"))

	is.Above(t, 1, 3)
	is.Slice(t, []int{})
	is.Element(t, []int{1, 2, 3}, 3)
	is.Substring(t, "example", "ample")
}

See the project page for more details.

The end of frontend

Posted October 2017 in #dev

The ultimate goal of frontend development, as a specialized field that sits between digital design and backend development, should be to disappear — to¬†innovate itself out of existence. And I think we’re getting close.

In time, more frontend tasks will be done by designers, though not in code. Prototypes are reaching a fidelity comparable to the finished product. It won’t be long until design tools learn to export complete components as actual code. Picture a tool between Sketch and Unity — an integrated design environment.

When design tools export trees of connected components, developers won’t have to infer intent from static mockups. We’ll no longer need the lossy translation step called a handover. What’s left is connecting endpoints to components, components to routes, and serving the resulting app to users.

While serving the content far from simple, it’s always the same: compile, optimize, minify, compress, distribute, localize, cache, serve. These are tasks to be solved once, by a generic proxy or an external service. But what about the rest of frontend — the wiring glue between routes, components, and endpoints?

These wires are just another layer of code, another step of the stack. It’s a layer as complex as any other, but not one that warrants its own field of development. Any technique unique to frontend should change to match the rest of the stack. Practices should apply across layers, and layers are better when built together.