What is Coding?

What is coding?

At its core, a program is a recipe: a numbered list of steps detailed enough that a machine with no common sense can follow it and get the same result every time. You write the recipe in a programming language, a notation humans can read that can be translated into something the computer understands.

A trivial example in Go looks like this:

package main

import "fmt"

func main() {
    name := "world"
    fmt.Println("Hello,", name)
}

That's six lines of precise instruction: declare a program, bring in a tool for printing, define an entry point, store the word "world" in a labeled box called name, and print a greeting. We'll unpack every part of this program in Chapter 4. For now, just notice that the code describes behavior using English-looking words and punctuation, not 1s and 0s.

How computers actually run code

Deep down, a CPU only understands one thing: binary instructions. Every program you've ever run (your browser, your game, this very web page's JavaScript) ends its life as a stream of 1s and 0s shuffling through silicon.

From source to silicon

A sequence of translations gets us from human-readable code to CPU-executable electricity:

Why binary?

Transistors (the building blocks of a CPU) are essentially switches: they're either on or off. We call those states 1 and 0. A modern CPU contains billions of them. By combining them into patterns, the hardware can represent numbers, characters, colors, and (crucially) the operations it should perform.

Here's a whirlwind translation of our Hello, world! in three layers, from the most human to the least:

// Level 1: Go source (what you read and write)
fmt.Println("Hello,", "world")

# Level 2: x86-64 assembly (roughly, a human-readable sketch of machine code)
MOV    RDI, addr_of_string
CALL   fmt.Println

# Level 3: Raw machine code (what the CPU actually decodes)
48 8D 3D 00 00 00 00
E8 00 00 00 00

You will never write level 3 by hand (and level 2 only in very niche situations). That's the whole point of a high-level language like Go: it keeps you in level 1 while handling levels 2 and 3 automatically.

Compiled vs interpreted

Languages differ in when the translation from source code to machine code happens. The three broad models are:

What each model trades off

Go is firmly in the compiled camp. When you run go build, Go produces a single, self-contained binary file that the CPU runs directly. No virtual machine, no interpreter, no "node_modules", no JVM. This is a big reason Go programs start so quickly and ship so easily (Chapter 4 will show this in action).

Types of programming languages

Besides when they translate (compiled vs interpreted), languages differ in what they're designed for. You'll hear people group them by family:

• Systems / general-purpose: build pretty much anything; performance-sensitive code, infrastructure, CLIs. Examples: Go, C, C++, Rust, Java.
• Scripting / dynamic: quick automation, glue code, prototypes, data analysis. Examples: Python, Ruby, Bash, Lua.
• Functional: emphasize pure functions and immutability. Examples: Haskell, Elixir, OCaml, Clojure.
• Markup: describe structure rather than behavior. Not really programming languages, but you'll read and write them constantly. Examples: HTML, XML, Markdown.
• Query: ask questions of data stores. Examples: SQL, GraphQL, SPARQL.
• Domain-specific: hyper-specialized. Examples: Dockerfile, Terraform HCL, regex, CSS.

Many languages fit in more than one box. Go, for instance, is general-purpose but especially loved for backend services, CLIs, and networked infrastructure.

Where Go fits

If you squint at the families above, you can see why someone would pick one over another for a given job. Where does Go sit?

• Speed of a compiled language: Go compiles to a static binary that runs as fast as C or C++ for most day-to-day code.
• Simplicity of a scripting language: the syntax is intentionally small. You can read a Go program you've never seen and roughly understand it. This is by design.
• Concurrency built in: go and channels are language keywords. No extra libraries needed. (Chapters 24–26.)
• Ergonomic tooling: formatter, linter, test runner, benchmark runner, and doc generator all ship with the compiler.
• A single deployable file: the classic Go pitch. Build once, copy the binary, run anywhere.

That's why Go powers so much modern infrastructure: Docker, Kubernetes, Terraform, Prometheus, etcd, CockroachDB, Caddy, Hugo, and so on. When you need a fast, reliable backend service or command-line tool, Go is a strong default. You'll meet each of these strengths firsthand throughout this course.

Why learn to code?

A quick aside worth reading if you're on the fence:

1. Problem-solving muscle. Coding teaches you to break fuzzy problems into tiny, precise steps. This skill transfers to basically everything else.
2. Leverage. A short script can do in seconds what would take a human hours, every week, forever.
3. Career optionality. Software touches every industry; coding skills expand what jobs and roles are available to you.
4. Creation, not just consumption. Knowing how software works changes you from a user into a maker. You can build the tool you wished existed.

Check your understanding

Practice exercises

package main

import "fmt"

func main() {
    languages := []string{"Go", "Python", "Rust", "JavaScript"}
    fmt.Println("Languages I know about:")
    for i, lang := range languages {
        fmt.Printf("  %d. %s\n", i+1, lang)
    }
    fmt.Printf("That's %d languages total.\n", len(languages))
}

Languages I know about:
  1. Go
  2. Python
  3. Rust
  4. JavaScript
That's 4 languages total.