Makefiles for Go Developers Image Makefiles for Go Developers

In this tutorial, we are going to be looking at how you, as a Go developer, can leverage the wonderful bit of technology that is Makefiles for fame and fortune when developing your own Go applications.

What are Makefiles?

Let’s start by looking at what Makefiles are first of all. Makefiles are an incredibly useful automation tool that you can use to run and build not just your Go applications, but for most programming languages.

You will typically see Makefiles at the root directory of a whole host of different Go applications on Github and in Gitlab as they are used extensively as the tool of choice for automating tasks that the maintainers of these applications find themselves doing often.

A Simple Example

Now that we have covered the absolute basic concepts, let’s see these concepts in action with a really simple Makefile example to whet our appetite.

Create a new directory in which you can work in and within this directory create a new file called Makefile.

Once you have this Makefile, open it up and let’s add a target called hello to this Makefile. This target, when executed, will run the script below it, very similar to a normal function in programming terms.

Makefile
hello:
    echo "Hello"

With this new defined, let’s try and execute this using the make command-line tool:

$ make hello
echo "Hello"
Hello

As you can see the script within the body of our hello target has been successfully executed for us and Hello has printed out!

Awesome, hopefully you can see where we are going with this.

Building a Simple Go App

So, we have a simple Makefile in a project directory that performs the highly complex tax of printing out Hello to our terminal.

Let’s now take this a step further and add a simple Go application into the mix so that we can try our hand at defining new targets which will build and run this new Go app for us.

main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello")
}

Now that we have a suitably complex Go application to work with, let’s define some new targets within our Makefile which will simplify the task of building and running our application for us.

Open up your Makefile once again and add the following targets:

Makefile
hello:
	echo "Hello"

build:
	go build -o bin/main main.go

run:
	go run main.go

Here, we have created a build target and a run target. The build target can be used to compile our amazing Go application it’s final binary state within a bin/ directory.

The run target is aptly named as it attempts to run our Go application in its current state.

Let’s try run these both now:

$ make build
go build -o bin/main main.go

Awesome, this make build command will have gone away and compiled our Go application successfully into a new bin/ directory for us.

Let’s now try the make run command:

$ make run
go run main.go
Hello

Here we see that our go application is run for us.

What’s the Big Deal?

At this point, you might be asking what the big deal is about using Makefiles for your own Go applications.

Well imagine you wanted to cross-compile your application to run on every OS and every architecture available but didn’t want to manually set the GOOS and GOARCH variables for every command.

Within your Makefile, you could define a new compile target which contains all of the build commands with all the appropriate GOOS and GOARCH compinations set like so:

Makefile
compile:
	echo "Compiling for every OS and Platform"
	GOOS=freebsd GOARCH=386 go build -o bin/main-freebsd-386 main.go
	GOOS=linux GOARCH=386 go build -o bin/main-freebsd-386 main.go
	GOOS=windows GOARCH=386 go build -o bin/main-freebsd-386 main.go

And now, when you try to cross compile for every platform, you simply have to call make compile:

$ make compile
echo "Compiling for every OS and Platform"
Compiling for every OS and Platform
GOOS=freebsd GOARCH=386 go build -o bin/main-freebsd-386 main.go
GOOS=linux GOARCH=386 go build -o bin/main-freebsd-386 main.go
GOOS=windows GOARCH=386 go build -o bin/main-freebsd-386 main.go

With everything successfully built, you should now see your bin/ directory full of binaries compatible with a range of different Operating Systems and Platforms.

Layering Commands

Let’s now imagine we are working with a complex system that has a multi-stage build/run process that has developed over many years. Instead of having to define all of the commands needed to build and run in a single target, you can break everything up into smaller targets and have something like an all target combine them into one make command.

Open up your Makefile once again and add an all target at the bottom. This all target will go away and execute your hello and build targets in series.

Makefile
hello:
	echo "Hello"

build:
	go build -o bin/main main.go

run:
	go run main.go


compile:
	echo "Compiling for every OS and Platform"
	GOOS=linux GOARCH=arm go build -o bin/main-linux-arm main.go
	GOOS=linux GOARCH=arm64 go build -o bin/main-linux-arm64 main.go
	GOOS=freebsd GOARCH=386 go build -o bin/main-freebsd-386 main.go

all: hello build

Now that we have added this new target, let’s see what happens when we call it:

$ make all
echo "Hello"
Hello
go build -o bin/main main.go

Awesome, using this approach we can start to break down more complex instructions into a series of smaller, easier to digest targets that can be individually debugged and executed.

Conclusion

So, in this tutorial, we covered the absolute minimum needed to get up and running using Makefiles and the make command so that you can simplify your development process.

Further Reading

If you enjoyed this article but wish to learn more about Makefiles and how you can best use them, I suggest you check out the following articles:

Elliot Forbes

Elliot Forbes
Twitter: @Elliot_f

Hey, I'm Elliot and I've been working on TutorialEdge for the last 4 years! If my work has helped you in any way, shape, or form then please consider supporting my work.

become a patron Buy Me A Coffee