Mastering the Basics of Go Programming (Blog 2 of the Go Series)

Mastering the Basics of Go Programming (Blog 2 of the Go Series)

Go, the versatile programming language employs a structured approach to code organization through packages. Every Go file commences with a crucial package clause, setting the stage for effective software structuring. Within a package, you'll find one or more source files, typically referred to as .go files, which meticulously define the package's functionality and purpose.

Essential Components of Go Structure

As you delve into the world of Go programming, you'll encounter a consistent structure within almost every Go file, comprising:

  1. The Package clause

  2. Import statements

  3. The Main code

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go.")

Concept of Packages

Packages serve as the backbone of Go programming, assembling a collection of source files within a common directory that undergoes unified compilation. This interconnectedness allows functions, types, variables, and constants declared in one source file to seamlessly interact with others residing within the same package.

The package clause assigns the package's name, defining its role and contribution within the larger codebase. For instance, in the classic "Hello World" example, the special package main takes the spotlight, a necessity for direct execution—typically from a terminal and a package fmt is imported.

fmt is a package that provides text formatting and printing functionality.

Concept of Modules

In Go development, repositories contain valuable modules, each grouping related Go packages together. Typically, a Go repository has a main module at its core, serving as a central focus within the repository's layout.

At the heart of this setup is the go.mod file, located in the repository. This file defines the module's path, determining the prefix for importing packages within the module. Notably, the module covers packages in its main directory and subdirectories, until reaching a neighboring subdirectory with its own go.mod file.

It's worth noting that you possess the freedom to define a module locally, devoid of any remote repository dependency. This flexibility underscores Go's pragmatic approach to modularization.

A module is a collection of Go packages stored in a file tree with a go.mod file at its root.

Importing Statements

Go files work together seamlessly through import statements, which act as a way to connect and integrate various code pieces. Import paths serve as keys that unlock external packages, allowing different code resources to come together.

Before a file can use code from other packages, it needs to establish these import connections. Go optimizes this process by selectively loading only the necessary packages, which is more efficient compared to a monolithic approach that could slow things down.

Diving deeper, a package's import path closely matches its module path, combined with its subdirectory within that module. Notably, standard library packages follow a distinct path, bypassing the module path prefix.


The essence of functionality takes shape in the last part of each Go file, where one or more functions bring the code to life. Functions, like interpretive passages in literature, consist of lines of code that are designed to be called from different parts of your program.

When the program runs, the center of attention is often on a function named main. Its pivotal role as the starting point is set by the compiler's directive.

Bringing Your Creation to Life

With your code ready for action, you can showcase your creation to the world using these steps:

Place your code in a file named hello-world.go and invoke the power of go run to kickstart its runtime journey.

go run hello-world.go
hello world

The narrative evolves when the need arises to manifest binaries. Akin to forging a masterpiece, the go build command assumes center stage:

go build hello-world.go
hello-world    hello-world.go

With your binary materialized, seize the opportunity to unveil its brilliance through direct execution:

hello world

In this carefully orchestrated journey, you've explored the basics of Go programming, blending packages, modules, imports, and functions into a seamless whole. With this newfound knowledge, you're now ready to tackle more complex coding adventures, crafting software that reflects your creative ideas and technical skills.

Did you find this article valuable?

Support Chetan Thapliyal by becoming a sponsor. Any amount is appreciated!