Introduction to Go 🐹

1️⃣ What is Go?

Go (also called Golang) was created at Google in 2009 to fix everyday frustrations: slow compile times, messy dependencies, and how hard it was to write programs that do many things at once. It stands on four ideas you'll feel in every project:

• • Compiled — Go translates your code straight into a single native binary (one runnable file) before it runs. There's no separate runtime to install on the machine that runs it.
• • Fast — that binary starts in milliseconds and runs close to C speeds, while the compiler itself is famously quick.
• • Simple — the whole language has only 25 keywords. There's usually one obvious way to do something, so code stays easy to read.
• • Built-in concurrency — doing many tasks at once (a web server handling thousands of users, for example) is part of the language itself via goroutines, not bolted on later.

That combination is why Go powers Docker, Kubernetes, and a huge slice of modern cloud infrastructure. In this lesson you'll start where every Go programmer starts: a tiny program that prints text. Read the worked example below first — every line is explained — then run it yourself.

// Every Go file starts by declaring which package it belongs to.
// "main" is special: it tells Go this program can be run directly.
package main

// import brings in code other people wrote. "fmt" (say "fumpt")
// is the standard library's package for formatting and printing.
import "fmt"

// func main() is the entry point. When you run the program,
// Go calls this function first. The { must be on THIS line.
func main() {
    // Println = "print line". It writes its text, then a newline.
    fmt.Println("Hello, World!")          // -> Hello, World!
    fmt.Println("My first Go program!")   // -> My first Go program!
}

Hello, World!
My first Go program!

2️⃣ The Four Parts of Every Go Program

Look back at that example. Every Go program you ever write has the same four building blocks, in this order:

• • package main — declares which package this file belongs to. The name main is special: it marks a program you can run (as opposed to a library other code imports).
• • import "fmt" — pulls in the fmt package (say "fumpt"), Go's standard toolkit for formatting and printing text.
• • func main() { — defines the entry point. When you run the program, Go calls main first. The opening { must sit on the same line as func main().
• • fmt.Println(...) — the actual work. Println means "print line": it writes its values and then moves to a new line.

This next example shows the small but important differences between Println (adds a newline and spaces) and Print (adds neither). Read the comments, predict the output, then check.

package main

import "fmt"

func main() {
    // Println can take several values; it puts a SPACE between them.
    fmt.Println("Go", "is", "fast")        // -> Go is fast

    // Each Println call starts a brand-new line.
    fmt.Println("Line one")                // -> Line one
    fmt.Println("Line two")                // -> Line two

    // Print (no "ln") does NOT add a newline — notice both words
    // land on the same line below, joined with no space.
    fmt.Print("No")
    fmt.Print("Newline")                   // -> NoNewline
    fmt.Println()                          // an empty Println ends the line
}

Go is fast
Line one
Line two
NoNewline

Your turn. The program below works once you fill in the two blanks marked ___. Follow the 👉 hints, then run it and compare with the expected output.

package main

import "fmt"

func main() {
    // 🎯 YOUR TURN — replace each ___ then run it.

    // 1) Print a greeting with your own name in it
    fmt.Println(___)   // 👉 put text in "double quotes", e.g. "Hi, I'm Sam"

    // 2) Print a second line about why you're learning Go
    fmt.Println(___)   // 👉 more text in "double quotes"

    // ✅ Expected output (example):
    //    Hi, I'm Sam
    //    I'm learning Go to build fast tools
}

Hi, I'm Sam
I'm learning Go to build fast tools

3️⃣ Running Your Code with go run

To run a Go file on your own machine, you save it (for example as main.go) and use the go run command in your terminal. It compiles and runs the program in one step — perfect while you're learning and experimenting.

# Save your code in a file called main.go, then run it:
go run main.go

# That single command compiles AND runs the program.
# To produce a standalone binary you can ship, build it instead:
go build -o hello main.go
./hello

# Check which version of Go you have installed:
go version

Hello, World!
My first Go program!

One more guided exercise to lock in the structure. Three pieces of the skeleton are missing — fill each ___ using the hints.

// 🎯 YOUR TURN — three things are missing. Fill in each ___.

// 1) Declare the runnable package
___ main          // 👉 the keyword that starts the file, then: main

// 2) Import the printing package
import "___"      // 👉 the standard package that holds Println

// 3) Name the entry-point function Go runs first
func ___() {      // 👉 the special function name Go looks for
    fmt.Println("It compiles!")
}

// ✅ Expected output:
//    It compiles!

It compiles!

package main

import "fmt"

func main() {
    // 🎯 MINI-CHALLENGE: An "about me" card
    // 1. Print a line with your name.
    // 2. Print a line with the year you started coding.
    // 3. Print a line with one thing you want to build.
    // (Three separate fmt.Println calls — text goes in "double quotes".)
    //
    // ✅ Example output:
    //    Name: Alex
    //    Coding since: 2026
    //    Goal: a command-line to-do app

    // your code here
}

Name: Alex
Coding since: 2026
Goal: a command-line to-do app