Before you start: a repository, and a leaderboard

Every chapter in this book ends with an assignment. You write it, you commit it with an exact message, and you push it. This chapter sets that up, and it takes about ten minutes.

Do it now rather than at chapter four, because the habit is the point and a habit started late is usually not started.

Why the assignments are pushed rather than just done

Three reasons, and the third is the one that matters.

You will finish them. Work that leaves your machine gets finished. Work that stays in a scratch file gets abandoned at the interesting part, which is usually one step before the thing it was teaching.

You will have something to show. By the end of this book your repository holds fifty-odd small Go programs, each one solving a named problem, each with a readable commit history. That is a more convincing portfolio than a single large project, because it shows range and it shows persistence.

You are not doing it alone. The commits are scored on a leaderboard shared with everybody else working through this book, which is what the rest of this chapter is about.

Step one: make the repository

mkdir go-journey && cd go-journey
git init

One repository for the whole book. Not one per chapter: the history is the record, and a single timeline is what makes the progression visible.

Give it a structure that will still make sense at chapter fifty:

go-journey/
├── README.md
├── part1-language/
│   ├── 01-why-go/
│   ├── 02-hello/
│   └── ...
├── part2-ideas/
├── part3-standard-library/
├── part4-grit/
├── part5-building/
└── part6-from-scratch/

Each assignment gets a directory with its own main.go, and where it needs one, its own go.mod:

mkdir -p part1-language/02-hello && cd part1-language/02-hello
go mod init go-journey/part1/hello

go work init
go work use ./part1-language/02-hello

Write a README.md on day one, because you will not write it later:

# go-journey

Working through *Go for JavaScript Developers*, one assignment per chapter.

| Part | What it covers |
|---|---|
| 1 | The Go language, against the JavaScript I already knew |
| 2 | Interfaces, errors, goroutines, channels, context |
| 3 | Files, HTTP, databases, shipping a binary |
| 4 | The Grit framework |
| 5 | Building real applications |
| 6 | Building things from scratch: a parser, a database, a server |

Then push it:

git add .
git commit -m "Setup - Repository"
git branch -M main
git remote add origin git@github.com:YOUR-NAME/go-journey.git
git push -u origin main

Make the repository public. The leaderboard reads public activity, and a public learning repository has never cost anybody a job.

Step two: the Committed app

Install Committed from the Play Store:

play.google.com/store/apps/details?id=com.desishub.committed

Sign up with your GitHub account, which is how it sees your commits. There is nothing to configure after that.

Step three: join the Gopher League

Open the app and join with the code:

5TCLJ27Z

Or follow the link, which does the same thing:

https://committed-api.gritframework.dev/join/5TCLJ27Z

The group's description says what it is:

#block(width: 92%, inset: 10pt, radius: 3pt, fill: rgb("#f6f7f9"), stroke: 0.5pt + rgb("#e3e6ea"))[ #set text(size: 10pt, style: "italic") Gopher League is a friendly leaderboard for developers learning Go together. Every commit, merged PR, review and closed issue earns points. Ship Go, climb the table, and get crowned weekly champion. ]

Commits score. So do merged pull requests, reviews and closed issues, which is worth knowing: reviewing somebody else's assignment is worth points, and it is also one of the better ways to learn.

Step four: the commit convention

Every assignment in this book carries an exact commit message, printed in its own box:

git commit -m "Variables - Assignment One"

Use the message exactly as printed. It is not decoration. The leaderboard matches on it, and a commit called "did the variables thing" earns nothing, which is a sad way to lose a week's points.

The pattern is always the same:

<Topic> - Assignment <Number>

So the first few are Hello Go - Assignment One, Variables - Assignment One,Variables - Assignment Two, and so on.

The loop, for every chapter from here

# 1. a directory for the assignment
mkdir -p part1-language/03-types && cd part1-language/03-types
go mod init go-journey/part1/types

# 2. write it, and run it until it works
go run .

# 3. commit with the exact message from the book
git add .
git commit -m "Variables - Assignment One"
git push

Four commands, maybe fifteen minutes per chapter. The leaderboard updates on its own.

There is more practice on the website

The Grit documentation has a Go guide with forty six interactive exercises, which run in the browser with a solution to check against:

gritframework.dev/docs/prerequisites/golang

They cover the same ground as Parts I to III and are shorter than this book's assignments, so they work well as a warm-up before a chapter or as revision after it. Where one lines up with a chapter, that chapter's assignment says so.

The division worth knowing: *the website exercises are for practising a concept, and this book's assignments are for building something and pushing it*. Do both if you have time, and if you only do one, do the assignment, because that is the one that leaves your machine.

Assignment

Commit your work with the message Setup - Repository, exactly as written, so the leaderboard can score it.

git config user.email "the-email-on-your-github-account"