How to Code in Go: A Simple Beginner’s Guide to Learning Go Programming

Introduction: So, You Want to Learn Go Programming?

Learning to code can feel confusing at first.

You open a programming tutorial, see strange words like func, package, import, and var, and suddenly wonder whether you have entered the wrong classroom.

Don't worry. Every programmer has been there.

If you're looking for a programming language that is relatively simple to read, quick to compile and useful for building real software, Go is worth exploring.

Go, also known as Golang, was developed at Google. It was designed to address a common problem developers faced: some programming languages were easy to write but slow to run, while others performed well but took too long to compile.

Go was designed to bring together three important qualities:

Fast compilation.
Ease of programming.
Efficient performance when running applications.

It also has a relatively small set of keywords, built-in tools and a straightforward approach to organising code.

But what does learning Go actually involve? What should you understand first, and how do you move from writing a few lines of code to building something useful?

Let's take it one step at a time.

1. What Exactly Is Go Programming?

Go is a general-purpose programming language used to create software applications.

Think of a programming language as a way of giving instructions to a computer. You write instructions using a language the computer's development tools can understand, and those tools turn your code into a program that can run.

For example, imagine you want your computer to display a welcome message.

You could write:

package main

import "fmt"

func main() {
    fmt.Println("Welcome to Go!")
}

When you run this program, the computer displays:

Welcome to Go!

That's a complete, simple Go program.

You have just told the computer to display a message. It may look small, but this example introduces several important parts of Go.

Go is particularly useful for networking and distributed systems, and it is widely associated with cloud software development. Its tools also allow developers to build programs for different operating systems and computer architectures.

The interesting thing is that you don't need to understand all of that before writing your first program.

Start small. Understand what each line does. Then build from there.

2. Set Up Your Computer Before Writing Code

Before you can write and run Go programs, you need to install Go and prepare a development environment.

A development environment is simply the collection of tools and settings you use to write, test and run your programs.

The book covers setting up Go on three operating systems:

Ubuntu Linux.
macOS.
Windows.

The installation process differs slightly depending on the computer you use, but the goal is the same: install Go, make its tools available from your command line and prepare a place to keep your projects.

What is the command line?

The command line is a text-based way to communicate with your computer.

Instead of clicking through several menus, you type commands and receive responses.

For example:

go version

This command checks the installed Go version.

If Go is properly installed and available in your system's PATH, your terminal should display its version information.

You will also need a place to organise your Go projects. The book explains the traditional Go workspace structure, including directories such as src and bin.

One useful distinction is that your Go installation and your own project files are not the same thing. The installation contains the tools used to build programs, while your project directory holds the code you write.

A practical tip: Don't rush through installation. If your environment is not configured properly, you may spend more time fixing setup problems than learning to program.

Also, installation instructions can change as Go and operating systems receive updates. Use current installation instructions for your operating system rather than blindly copying old commands from a tutorial written for an older release.

3. Write Your First Go Program

Now comes the interesting part.

Most programming beginners start with a program called Hello, World!

It is a small program that displays a message on the screen. Its purpose is to help you confirm that your development environment works and introduce you to the basic structure of a Go application.

Create a file named hello.go and write:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Save the file and run:

go run hello.go

You should see:

Hello, World!

Congratulations! You've written and run your first Go program.

But let's understand what you actually wrote.

package main

This tells Go that the file belongs to the main package. A main package is used to create an executable program.

import "fmt"

This brings in the fmt package from Go's standard library. It provides functions for formatting and displaying information.

func main()

This defines the main function. It is the entry point where an executable Go program begins running.

fmt.Println()

This tells Go to display the information inside the parentheses.

Once you understand these four parts, the first program becomes much less mysterious.

4. Understand Variables and Data Types

Programs need information to work with.

For example, a school management application may need students' names, ages, examination scores and registration status.

A shopping application may need product names, prices and quantities.

Go uses variables to store this information.

Think of a variable as a labelled container. You give it a name and place a value inside it.

For example:

name := "David"
age := 25

Here, name stores the text "David", while age stores the number 25.

You can display both values:

fmt.Println(name)
fmt.Println(age)

What are data types?

A data type tells Go what kind of value a variable holds.

Some common Go data types include:

Data type	What it stores	Example
`string`	Text	`"David"`
`int`	Whole numbers	`25`
`float64`	Decimal numbers	`25.5`
`bool`	True or false	`true`

Why does this matter?

Imagine asking a computer to add a person's name to their age. That doesn't make sense as a mathematical operation.

Go uses data types to help prevent operations that don't make sense.

You can also convert values from one type to another when necessary.

For example, a number may need to be converted into text before being combined with a sentence.

What about constants?

A constant is a value that you declare once and do not change later.

For example:

const country = "Nigeria"

You can use country throughout your program, but you cannot assign it a different value.

A simple way to remember the difference is this:

A variable can change.
A constant stays the same.

5. Learn How Strings Work in Go

Strings are simply pieces of text.

They can contain letters, numbers, spaces and symbols.

For example:

message := "Learning Go is interesting"

Go gives you different ways to work with strings.

You can display them:

fmt.Println(message)

You can join them together:

firstName := "David"
lastName := "James"

fmt.Println(firstName + " " + lastName)

Output:

David James

This process is called string concatenation.

You can also format strings when you want information to appear in a particular way.

For example:

name := "David"
age := 25

fmt.Printf("My name is %s and I am %d years old.\n", name, age)

Output:

My name is David and I am 25 years old.

Here, %s represents a string, while %d represents an integer.

Go also has a strings package with useful functions for working with text, such as checking whether a string contains particular words or changing its letter case.

This becomes especially useful when building applications that process names, messages, search terms and other text.

6. Understand Arrays, Slices and Maps

At some point, storing every piece of information in a separate variable becomes inconvenient.

Imagine building a program that stores the names of 100 students. Creating 100 individual variables would be unnecessarily difficult.

Go provides different ways to organise collections of information.

Three important ones are arrays, slices and maps.

Arrays

An array stores a fixed number of elements of the same type.

For example:

scores := [3]int{70, 85, 90}

This creates an array containing three numbers.

The important thing to remember is that its length is fixed.

Slices

A slice is similar to an array, but its length can change.

For example:

scores := []int{70, 85, 90}

scores = append(scores, 95)

fmt.Println(scores)

Output:

[70 85 90 95]

Notice what happened? We added another score without creating a completely new collection.

Slices are useful when the number of items may change as your program runs.

Maps

A map stores information as key-value pairs.

Think of a contact list. You have a person's name and their phone number. You use the name to find the corresponding number.

In Go, you can create a map like this:

student := map[string]int{
    "David": 85,
    "Sarah": 92,
}

fmt.Println(student["David"])

Output:

Here, "David" is the key, and 85 is the value.

So, when should you use each?

Use an array when you need a fixed-size collection.
Use a slice when the collection may grow or shrink.
Use a map when you need to find values using keys.

Understanding these three structures makes it much easier to organise information in your applications.

7. Make Your Programs Think with Conditions

A useful program should be able to make decisions.

For example, imagine writing a program that checks whether a student passed an examination.

You could tell the program:

If the score is 50 or above, display "Passed".
Otherwise, display "Failed".

Go uses conditional statements to make this possible.

Here's a simple example:

score := 75

if score >= 50 {
    fmt.Println("Passed")
} else {
    fmt.Println("Failed")
}

Output:

Passed

The program checks the score and chooses the correct result.

Go also supports else if when you need to check several conditions.

For example, you could classify examination results as excellent, good, average or poor.

What is a switch statement?

A switch statement is another way to make decisions.

It is particularly useful when you want to compare one value against several possible cases.

day := "Monday"

switch day {
case "Monday":
    fmt.Println("Start of the week")
case "Friday":
    fmt.Println("Almost the weekend")
default:
    fmt.Println("Another day")
}

Instead of writing several separate conditions, you can organise the choices using switch.

8. Use Loops to Repeat Tasks

Computers are excellent at repeating tasks.

Suppose you want to display the numbers from 1 to 5.

You could write five separate print statements, but that would be a waste of time.

A loop allows you to repeat an instruction.

Go uses the for keyword for loops.

for i := 1; i <= 5; i++ {
    fmt.Println(i)
}

Output:

Let's break it down.

i := 1 starts the counter at 1.
i <= 5 tells the loop to continue while the counter is 5 or less.
i++ increases the counter by one after each round.

The computer repeats the instruction until the condition is no longer true.

Go also provides break and continue.

break stops a loop, while continue skips the current round and moves to the next one.

For example, imagine checking a list of products but wanting to skip products that are out of stock. A continue statement can help you skip those items without stopping the entire loop.

9. Learn Functions and Make Your Code Reusable

Imagine writing the same block of code every time you want to calculate the total price of an order.

That would quickly become frustrating.

Functions solve this problem.

A function is a reusable block of code designed to perform a particular task.

Here's a simple example:

func greet() {
    fmt.Println("Welcome to my program!")
}

You can call this function whenever you need it:

greet()

You don't have to rewrite the message each time.

Functions can accept information

You can also give a function information to work with. This information is called a parameter.

func greet(name string) {
    fmt.Println("Hello,", name)
}

Now you can call it like this:

greet("David")
greet("Sarah")

Output:

Hello, David
Hello, Sarah

The same function works for different names.

Functions can return results

A function can also calculate something and send the result back.

func add(a int, b int) int {
    return a + b
}

You can use it like this:

result := add(10, 5)

fmt.Println(result)

Output:

Go also supports functions that return multiple values, variadic functions that accept a variable number of arguments, and other useful features.

The main lesson is simple: functions help you avoid unnecessary repetition and make your code easier to organise.

10. Understand Errors Before They Become Bigger Problems

Here's something every beginner needs to understand: programs do not always work perfectly.

A user may enter the wrong information. A file may not exist. A network connection may fail.

What happens then?

Your program needs a way to recognise the problem and respond properly.

Go handles many expected problems using errors.

An error is a value that communicates that something went wrong.

For example:

package main

import (
    "errors"
    "fmt"
)

func checkName(name string) error {
    if name == "" {
        return errors.New("name cannot be empty")
    }

    return nil
}

func main() {
    err := checkName("")

    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("Name accepted")
}

Output:

name cannot be empty

Let's understand the important parts.

errors.New() creates an error with a message.

err != nil checks whether an error was returned.

return nil indicates that no error occurred in this example.

This approach allows your program to handle problems instead of blindly continuing as though everything is fine.

What is the difference between an error and a panic?

You will also encounter something called a panic in Go.

A panic happens when the program encounters an unexpected situation that causes normal execution to stop.

For example, trying to access an element outside the valid range of a slice can cause a panic.

Go provides defer and recover for particular situations involving cleanup and recovering from panics.

However, don't confuse panic handling with ordinary error handling. Expected problems should generally be handled using errors rather than deliberately causing panics.

11. Organise Your Code with Packages

As your program becomes bigger, putting everything into one file can make it difficult to manage.

Imagine building a shopping application. You may have code for customers, products, payments and orders.

Keeping all of that in one place would quickly become messy.

Go uses packages to organise related code.

A package is a collection of Go source files within a directory that work together under the same package name.

You can import packages when you need their functionality.

For example:

import "fmt"

This imports Go's formatting package.

Go also has a standard library containing packages that help developers perform common tasks without having to create everything themselves.

You can create your own packages too.

Another important concept is package visibility.

In Go, whether a name begins with an uppercase or lowercase letter affects whether it can be accessed from another package.

For example:

type Student struct {
    Name string
}

The name Student begins with an uppercase letter, making it exported and accessible to other packages.

This naming rule is one of the small details worth learning early because it affects how you organise larger applications.

12. Understand Pointers, Structs and Methods

These concepts may sound complicated at first, but they become easier when you connect them to everyday examples.

What are pointers?

A pointer stores the memory address of another value.

Think of it as having a location instead of holding the actual item itself.

In Go, the & operator can be used to get the address of a variable, while * is used to work with the value through a pointer.

Example:

age := 25

pointer := &age

fmt.Println(*pointer)

Output:

The pointer refers to the location of age, and *pointer accesses the value stored there.

Pointers are useful when you need functions or methods to work with the original value rather than just a copy.

What are structs?

A struct allows you to group related information together.

Imagine a student record containing a name, age and score.

Instead of keeping these details in unrelated variables, you can create a struct:

type Student struct {
    Name  string
    Age   int
    Score int
}

Now you can create a student:

student := Student{
    Name:  "David",
    Age:   20,
    Score: 85,
}

fmt.Println(student.Name)

Output:

David

A struct is like a form with different fields. Each field stores a particular piece of information about the same thing.

What are methods?

A method is a function associated with a particular type.

For example:

type Student struct {
    Name string
}

func (s Student) Introduce() {
    fmt.Println("My name is", s.Name)
}

You can call the method like this:

student := Student{Name: "David"}

student.Introduce()

Output:

My name is David

Methods help you keep behaviour connected to the data it works with.

13. Learn About Interfaces and Why They Matter

Interfaces are an important part of writing flexible Go programs.

An interface describes behaviour that a type must provide.

Rather than requiring a function to work with only one specific type, an interface can allow it to work with different types that share the required behaviour.

Let's use a simple example.

Imagine you have different creatures in a program. Some can swim, and you want to create a function that works with anything capable of swimming.

You could define an interface:

type Swimmer interface {
    Swim()
}

Any type that has a matching Swim() method satisfies this interface.

This means you can write code that works with different types without needing to know every detail about them.

Why is that useful?

Because it makes your code more flexible and easier to test.

You can change or add types without having to rewrite every function that uses them.

The book also demonstrates how interfaces work with methods and pointers, showing how Go uses behaviour to connect different parts of an application.

14. Use defer and init at the Right Time

Go has two additional features worth understanding as your programs become more advanced.

The defer statement

defer schedules a function call to run when the surrounding function is about to finish.

It is often useful when you need to clean up something after using it.

For example, if your program opens a file, you will eventually need to close it.

You can use:

defer file.Close()

This schedules the file to close when the surrounding function returns.

It helps keep cleanup instructions close to the code that creates or uses a resource.

The init function

Go also supports a special function called init().

It runs automatically when a package is initialised, before the main function begins running in an executable program.

It can be useful for certain setup tasks that need to happen before the rest of the program uses a package.

However, use it thoughtfully. Code that runs automatically can sometimes make a program harder to understand if you put too much logic inside it.

15. Build and Install Your Go Programs

Writing code is only part of the job. At some point, you will want to turn your source code into a program that can be run and shared.

Go provides tools for this.

One command you will use while learning is:

go run main.go

This compiles and runs the program for you.

But what if you want to create an executable file?

That's where go build comes in.

go build

This command builds your Go application into an executable binary.

A binary is the file produced from your source code that your computer can execute.

Go's build tools include the support code needed by the application, which makes distribution straightforward for compatible target systems.

You can also install Go programs using the appropriate Go tooling so they are available from your system's command line.

This is an important step because it takes you beyond experimenting with code and introduces you to preparing software for actual use.

16. Build Go Applications for Different Operating Systems

Here's another useful feature of Go: you can build applications for different operating systems and computer architectures.

For example, you might write an application on a Windows computer but need to produce a version that runs on Linux.

Go provides environment variables such as GOOS and GOARCH to control the target operating system and architecture during a build.

For example:

GOOS=linux GOARCH=amd64 go build

This tells the Go build tools to produce a Linux executable for the specified architecture.

You can also use build tags and filename conventions to organise code that should only be included for particular platforms.

Why does this matter?

Because developers don't always build software for the computers they personally use. An application may need to run on several different systems.

Go makes this process much more manageable.

17. Use Command-Line Flags to Make Programs More Useful

A command-line flag allows someone running your program to provide information or options when starting it.

Imagine creating a program that welcomes users.

Instead of writing a separate program for every name, you could allow someone to supply a name when running it.

Go provides the flag package to help developers work with command-line options.

This is particularly useful when building small utilities, automation tools and applications that need configurable behaviour.

It is a good example of how a simple Go program can gradually become a more practical tool.

18. How Should You Practise Go as a Beginner?

Reading about programming is useful, but reading alone will not make you a programmer.

You need to write code, run it, make mistakes and figure out what went wrong.

Here is a practical learning path based on the topics covered in the book.

Stage 1: Get comfortable with the basics

Install Go and prepare your development environment.
Write your first Hello, World! program.
Understand packages, imports and the main function.
Learn comments, variables and constants.

Stage 2: Learn how to work with information

Practise strings and string formatting.
Understand data types and type conversion.
Work with mathematical operators.
Learn arrays, slices and maps.

Stage 3: Make your programs perform tasks

Practise if and switch statements.
Write loops using for.
Learn functions and function arguments.
Understand break, continue and defer.

Stage 4: Write better organised programs

Create and import packages.
Learn pointers and structs.
Work with methods and interfaces.
Practise handling errors and understanding panics.

Stage 5: Learn how to prepare your applications

Build and install Go programs.
Work with command-line flags.
Learn about build tags.
Explore building for different operating systems and architectures.

Five small projects to practise what you've learned

Don't wait until you know everything before trying to build something.

Here are five beginner-friendly ideas:

A simple calculator: Practise variables, operators, functions and conditional statements.
A student score checker: Use maps, conditions and loops to organise and check examination scores.
A contact book: Store names and phone numbers using maps and practise searching for information.
A basic expense tracker: Use structs and slices to store expenses and calculate totals.
A command-line greeting program: Use functions and command-line flags to let users customise their greetings.

These projects are small enough to start with, but each one gives you an opportunity to combine several Go concepts.

For every project, try to write the code yourself before looking for a complete solution. When something fails, read the error message and investigate it. That process is part of learning.

19. Is Go a Good Programming Language for Beginners?

Yes, Go can be a good choice for beginners, especially those who appreciate clear syntax and a relatively small set of language features.

Here are some reasons:

It has a simple structure. Go avoids unnecessary language complexity and has a relatively small set of keywords.

It compiles quickly. Its compilation speed makes testing and developing applications more convenient.

It has useful built-in tools. Developers can format, run, build and manage Go programs using its toolchain.

It supports different platforms. You can build applications for different operating systems and architectures.

It encourages organised code. Packages, structs, methods and interfaces help developers structure larger applications.

However, no programming language makes learning to code effortless.

You will still need to understand programming logic, practise solving problems and become comfortable reading errors.

The language can make the process easier, but your progress will come from what you do with it.

Final Thoughts: Start Small, Keep Building

Learning Go does not mean memorising every keyword or understanding every advanced concept before writing your first useful program.

Start with a simple message on the screen. Learn how variables work. Practise storing information, making decisions and repeating tasks. Then move on to functions, packages, errors, structs and interfaces.

As you improve, begin building small projects that solve actual problems.

One of the most useful lessons from How To Code in Go is its practical, topic-by-topic approach. You don't have to understand the entire language in one sitting. You can learn one concept, try its example, and move to the next.

And remember: making mistakes is not a sign that you cannot code. It is part of the process.

Your first program may only display "Hello, World!", but every useful application starts with someone writing that first line of code.

Pick a small project, open your editor and start writing.

Tokyo Posts