Tooling, Testing & Deployment

The Node toolchain is a collection. Go’s is a single binary.

As a TypeScript developer you are intimately familiar with assembling a toolchain from many moving parts:

• Formatting: Prettier
• Linting: ESLint + a pile of plugins
• Type-checking: tsc
• Testing: Jest (or Vitest)
• Bundling: webpack / esbuild / Vite
• Running: ts-node or tsx
• Dependency management: npm / yarn / pnpm

Each tool has its own config file, its own release cycle, and its own breaking-change surface. A non-trivial amount of every project’s setup time is spent wiring these together.

Go ships with all of the above as part of a single go binary that is installed alongside the language:

TypeScript / Node	Go equivalent
Prettier	gofmt / go fmt (built-in)
ESLint	go vet + staticcheck / golangci-lint
tsc	go build (type-checking is always on)
Jest / Vitest	go test (built-in)
webpack / esbuild	go build (produces a single static binary)
ts-node / tsx	go run
npm / yarn	go mod

No config bikeshedding

One of the most beloved aspects of Go’s toolchain is that there is no style configuration. gofmt has exactly one opinion about how Go code should look, and that is the end of the discussion. No .prettierrc, no .eslintrc, no arguing about tab width in pull requests.

This is a deliberate cultural choice in the Go community: code style is settled, so the conversation stays on architecture and logic.

Module overview

This module walks through each major tool in Go’s built-in suite and maps it directly to what you already know:

• gofmt, go vet, lint — formatting and static analysis
• Project layout — where code lives and why internal/ matters
• Docker multi-stage builds — shipping a tiny Go image vs a node_modules image
• Cross-compilation — a single binary for any OS/arch, no runtime required
• CI with GitHub Actions — a working Go workflow vs a Node workflow

TypeScript

// package.json (partial)
{
  "scripts": {
    "lint":   "eslint src --ext .ts",
    "format": "prettier --write src",
    "test":   "jest",
    "build":  "tsc && webpack",
    "start":  "ts-node src/main.ts"
  },
  "devDependencies": {
    "eslint": "^8",
    "prettier": "^3",
    "jest": "^29",
    "ts-jest": "^29",
    "webpack": "^5",
    "ts-node": "^10",
    "typescript": "^5"
  }
}

Go

# Makefile (optional convenience wrapper)
# Everything below is already in the "go" binary

lint:
    go vet ./...
    staticcheck ./...

fmt:
    go fmt ./...

test:
    go test ./...

build:
    go build -o bin/app ./cmd/app

run:
    go run ./cmd/app

🟦 go run vs ts-node

go run ./cmd/app compiles and runs in a single step — similar to ts-node src/main.ts. The key difference is that go run still produces a real compiled binary; it just places it in a temp directory and cleans up after. There is no interpreter at runtime.

Which Go command is the equivalent of running `ts-node src/main.ts`?

go build go run go exec go start

What is the Go equivalent of Prettier for code formatting?

go lint gofmt go style go check

Which Go command manages dependencies (like npm/yarn)?

go get only go mod go dep go pkg

Go's formatter gofmt is configurable — true or false?

True — via .gofmtrc True — via go.mod False — it has one style False — you must use golangci-lint instead

Submit

Mark as complete