Summary

This proposal suggests a “build.config” file inside a go package. The build configuration file is optional and used to specify custom build scripts for the package. It is similar to makefile but with cross-platform path and file manipulation commands. Go build tools should be aware of this build file and build the package accordingly.

Overview

Currently, Go has various tools to allow custom build operations: +build tag, +file tag, go generate, file suffixes, etc. It is possible that more custom build mechanisms may be added to the language in the future.

The problem with the current approaches is that the build specifications are scattered all over the place. It is difficult to see what is going on at a glance. Do you find the go generate in this file or that file?

Another problem is that go generate requires manual invocation. If the developer forgets to call go generate, the files and the resources may not get updated. There is also no intelligent incremental build with go generate.

There is no centralized place for future build-related expansion. Without a centralized place, future build-related expansion will only clutter the language specification (eg. more tags?).

In my Go projects, I often have to resort to makefile to pack resources, auto-generate files, and finally build the project. So far the solution is adequate but makefile is not very portable. There are workarounds, but they are in a weird, makefile-kind of way.

Proposal

This proposed solution is to allow a build configuration file in a package. The build file functions as a custom script to go build tool. There has to be a fixed name for it (eg. build.config) so that people would know where to look. The build file is optional and each package can contain a maximum of one build file.

Go build tool processes the build file first before carrying out the normal build. Processing the build file should be similar to makefile. Check for the specified dependencies and build them if they are out-of-date using the specified custom recipes.

The build file should be portable and work across platforms without any change. It should supports the following cross-platform commands:
• File and directory manipulation
• Filepath utilities

Benefits

There is a centralized place for build configuration. Future build-related expansion can be added here instead of adding more syntax or tags to the language. More supported commands can be added to the build file.

Go build now automatically ensures all resources and files are up-to-date.

Specifics

I envision the build file to have similar components to a typical makefile: targets, dependencies, and recipes, possibly with variable substitution for long names and paths.

Syntax-wise it should be similar to makefile for reduced learning curve, but json or yaml (or maybe Go?) is also fine.

Since the build file is meant for go tools and not manual invocation by the user, there is no need for phony targets. It should simplify the syntax a bit since all targets and dependencies are real actual files.

I don’t think it should support all makefile features. Probably we should just keep it simple with: targets, dependencies, recipes, and variables for the time being.

Let me know what you think.

Thanks.

Henry