Why I Switched from Makefile to Taskfile

Photo by Kelly Sikkema on Unsplash

Introduction

Software projects involve several phases, including building, testing, and deploying code.
For instance, compiling Go source code results in an executable, while frontend frameworks compile into HTML, CSS, and JavaScript files.
Testing is crucial before merging changes or releasing new versions. Deployment scripts often ship software to production.
Each phase requires different tools, typically command-line utilities with various flags and parameters.
Automation tools simplify these processes, enhancing efficiency in daily workflows.

Makefile

Makefiles are powerful tools that automate software project workflows. Initially developed for C programs, they now support diverse tasks like website generation and data processing.

A Makefile contains directives for the make utility to build or maintain programs and files. It defines tasks and their dependencies, ensuring efficient and reproducible builds.

I won’t dive into Makefiles in this blog post as I’m assuming the reader is familiar with the concept. If not, there is plenty of information over the internet (like this tutorial for example or it’s wikipedia page).

Advantages of Makefile:

• Integrated with the make utility, available on most Linux/MacOS systems.
• A well-established tool with nearly 50 years of history.

These are the main advantages I think Makefile have. However, Makefiles have limitations, particularly their syntax, which can be cumbersome for complex tasks.

Why I Switched

In one of my projects, I used a Makefile for tasks like running frontend/backend services and database migrations. Here's an example of a migration task:

migrate-up:
    GOOSE_DRIVER=postgres GOOSE_DBSTRING="user=app host=localhost port=5432 dbname=my-app sslmode=disable user=app" \
    goose -dir database/migrations up

I wanted to load environment variables from a .env file by default but allow overrides with ENV_FILE=.env.production. After struggling with Makefile syntax and solutions that didn't work, I sought alternatives.

Introducing Taskfile

Taskfile is a Go-based task runner using YAML syntax for defining tasks. It simplifies project workflows by automating repetitive tasks like building, testing, and deploying code.

Benefits of Taskfile:

• Readable YAML Syntax: Easier to understand than Makefiles.
• Single Binary: No dependencies beyond the Go runtime.
• Cross-Platform Support: Works on Linux, macOS, and Windows.

Here's how I solved my problem using Taskfile:

version: '3'
dotenv:
  - '.env'

tasks:
  migrate-up:
    cmds:
      - goose -dir database/migrations up

  migrate-up-prod:
    dotenv:
      - .env.production
    cmds:
      - echo executing DB migration on PRODUCTION ..
      - sleep 2 # allow time to cancel
      - goose -dir database/migrations up

Taskfile's intuitive API allowed me to quickly implement a solution that was both functional and readable.

Summary

Choosing the right tool can significantly impact productivity. While Makefile served its purpose initially, Taskfile offered a more elegant solution for my needs. Transitioning took less than 30 minutes and simplified my build process considerably.

If you're seeking an easy-to-use build tool, consider giving Taskfile a try.

Comments

[Illia Kaliuzhnyi]

One of the other features that we found really handy after switching from Makefiles to Task is the ability to include other Taskfiles. It makes them easier to use in a monorepo with multiple submodules that require their dedicated build, test targets, code/manifests generate, etc.
Also, ability to use go templates everywhere is a great bonus.