A Complete Guide - Writing and Running Your First Go Program

Last Updated: 03 Jul, 2025   
  YOU NEED ANY HELP? THEN SELECT ANY TEXT.

Writing and Running Your First Go Program

Prerequisites:

Before we begin, ensure you have Go installed on your system. You can download it from the mkdir -p $HOME/go/{bin,src,pkg}

  • Set the GOPATH and GOBIN Environment Variables:

    export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin
    • GOPATH is the root of your Go workspace.
    • GOBIN is the directory where binaries are installed.

    • Creating Your First Go Program:

    Let's create a simple "Hello, World!" program to get familiar with the syntax and workflow.

    1. Create a New Directory for Your Project:

      mkdir -p $GOPATH/src/helloworld
cd $GOPATH/src/helloworld

    2. Create a Go File:

      touch main.go

    3. Write a Simple Go Program: Open main.go in your preferred text editor and add the following code:

      package main import "fmt" func main() { fmt.Println("Hello, World!")
}
      • package main: Every executable Go program starts with package main.
      • import "fmt": Imports the fmt package, which contains functions to format input and output.
      • func main(): Defines the main function, the entry point of any Go program.
      • fmt.Println("Hello, World!"): Prints "Hello, World!" to the console.

    Compiling and Running the Go Program:

    1. Open a Terminal and Navigate to Your Project Directory:

      cd $GOPATH/src/helloworld

    2. Compile the Go Program:

      go build

      This command compiles the source code and creates an executable file named helloworld (or helloworld.exe on Windows).

    3. Run the Executable:

      ./helloworld

      You should see the output: Hello, World!

    Important Information:

    Step-by-Step Guide: How to Implement Writing and Running Your First Go Program

    Step 1: Install Go

    Before you can write and run a Go program, you need to have Go installed on your computer. Here’s how to do it for different operating systems:

    For Windows:

    1. Download the latest version from the .
    2. Open the .pkg file and follow the instructions in the installer.
    3. Open Terminal and type go version to verify the installation.

    For Linux:

    You can install Go using package managers or download it directly from the Go website.

    Using package manager (Ubuntu):

    sudo apt update
sudo apt install golang

    Download directly:

    1. Download the latest version from the sudo tar -C /usr/local -xzf go1.x.x.linux-amd64.tar.gz
    2. Add Go binary to your PATH by adding this line to your ~/.bashrc or ~/.profile: 
      export PATH=$PATH:/usr/local/go/bin
    3. Reload the configuration: 
      source ~/.bashrc
    4. Verify the installation: 
      go version

    Step 2: Set Up Your Workspace

    Go requires you to organize your Go files within a workspace. By default, the workspace directory is $GOPATH, which is set to $HOME/go.

    You can create this directory manually:

    mkdir -p $HOME/go/{bin,pkg,src}

    Alternatively, you can use go mod to manage dependencies outside of $GOPATH, which is more convenient for beginners. In this example, we'll use go mod.

    Step 3: Create Your First Go File

    Create a new file named hello.go in your preferred directory. You can create a project folder if you want to keep everything organized:

    mkdir -p $HOME/projects/go/hello
cd $HOME/projects/go/hello
touch hello.go

    Open hello.go in your preferred text editor and write the following code:

    package main import "fmt" func main() { fmt.Println("Hello, world!")
}

    Step 4: Initialize Go Modules

    Navigate to your project folder and initialize Go Modules:

    cd $HOME/projects/go/hello
go mod init hello

    This command will create a go.mod file that manages all dependencies for your project.

    Step 5: Compile Your Go Program

    Compile your Go program to check for any syntax errors:

    go build

    This command will produce an executable file named hello in your current directory.

    Step 6: Run Your Go Program

    Execute the compiled program:

    ./hello

    You should see the output:

    Hello, world!

    Alternative Method: Using go run

    Instead of compiling and then running your program, you can use the go run command to compile and execute the program in one step:

    go run hello.go

    This will output:

    Hello, world!

    Explanation of the Code

    Let's break down the provided Go code:

    package main
    • This line declares the package name. The main package is special because it defines a standalone executable program.
    import "fmt"
    • This line imports the fmt package, which contains functions for formatting I/O.
    func main() { fmt.Println("Hello, world!")
}
    • This function main() is the entry point of any Go program. When the program is executed, the main() function runs first.
    • fmt.Println("Hello, world!") prints the string "Hello, world!" to the console.

    Summary

    In this tutorial, you learned how to:

    1. Install Go.
    2. Set up a basic Go workspace.
    3. Write a simple Go program.
    4. Use go mod to initialize your project module.
    5. Compile and run your Go program using both go build and go run commands.
     YOU NEED ANY HELP? THEN SELECT ANY TEXT.

    Top 10 Interview Questions & Answers on Writing and Running Your First Go Program

    1. What is Go, and why should I learn it?

    Answer: Go, often referred to as Golang, is a statically typed, compiled programming language designed by Google. It's known for its simplicity, efficient syntax, and fast execution. Learning Go can be beneficial because it's widely used in cloud platforms, networking, and systems programming. Its concurrency features make it particularly suited for building scalable applications.

    2. How do I install Go on my computer?

    Answer: To install Go, follow these steps:

    • Windows: Visit the official Go website (golang.org/dl/), download the installer for Windows, and run it. Ensure you check the option to add Go to your PATH during installation.
    • macOS: Use Homebrew by running brew install golang in the terminal.
    • Linux: Use the package manager (e.g., sudo apt-get install golang on Ubuntu) or download the tarball from the official site and extract it.

    3. What is GOPATH in Go, and how do I configure it?

    Answer: GOPATH is an environment variable that tells Go where to find source code and installed packages. By default, it’s set to $HOME/go on Unix-like systems and %USERPROFILE%\go on Windows. To configure it, you can set the GOPATH environment variable in your shell configuration file (e.g., .bashrc, .zshrc). Alternatively, since Go 1.11, many Go tools automatically handle module paths, reducing the need to explicitly set GOPATH.

    4. How do I create and set up a new Go module?

    Answer: To create and set up a new Go module:

    1. Create a new directory for your project and navigate into it: 
      mkdir mygoapp
cd mygoapp
    2. Initialize a new Go module: 
      go mod init mygoapp

    This command creates a go.mod file which keeps track of your project's dependencies.

    5. What’s the basic structure of a Go program?

    Answer: A basic Go program includes a package declaration and a main function:

    package main import "fmt" func main() { fmt.Println("Hello, World!")
}
    • package main: This declares the package name. For executable programs, it must be main.
    • import "fmt": This imports the Format package to use the Println function.
    • func main(): This is the entry point of a Go application.

    6. How do I run my first Go program?

    Answer: To run your Go program:

    1. Save your code in a file with a .go extension, e.g., main.go.
    2. Use the go run command in the terminal: 
      go run main.go

    Alternatively, you can compile the program to create an executable:

    go build main.go

    This generates a binary named main, which you can run directly by typing ./main.

    7. How do I install dependencies in a Go project?

    Answer: Use Go modules:

    1. Initialize a module with go mod init (if you haven’t already).
    2. Import the required package in your code.
    3. Run your program with go run - Go will automatically resolve and fetch the dependencies listed in go.mod.

    For example:

    import "fmt"
import "github.com/example/package" func main() { fmt.Println(package.SomeFunction())
}

    Running go run main.go will install github.com/example/package if it’s not already present.

    8. How do I format my Go code?

    Answer: Go has a standard code formatting tool called gofmt. To format all Go files in your project:

    gofmt -w .

    This command writes the formatted code back to the files. Using a code editor with Go support can also automatically format your code on save.

    9. How do I handle errors in Go?

    Answer: Go uses explicit error handling instead of exceptions. Functions can return multiple values, with the last one often being an error. Here’s how you can handle errors:

    package main import ( "fmt" "os"
) func main() { f, err := os.Open("filename.txt") if err != nil { fmt.Println("Failed to open file:", err) return } defer f.Close() // Proceed with using the file
}

    Check if the error (err) is nil to determine if the operation was successful.

    10. How do I write unit tests in Go?

    Answer: To write and run unit tests in Go:

    1. Create a test file with the _test.go suffix in the same package, e.g., main_test.go.
    2. Write test functions that start with Test and take a single argument of type *testing.T. Here’s an example test for a simple function:
    package main import ( "testing"
) // Function to be tested
func Add(a, b int) int { return a + b
} // Test for the Add function
func TestAdd(t *testing.T) { result := Add(2, 3) if result != 5 { t.Errorf("Add(2, 3) = %d, want 5", result) }
}

    Run the tests using the go test command:

    go test

    This command will execute all test files in the current directory and report the results.

    You May Like This Related .NET Topic

    📥 Download Code ▶️ Watch Online 📖 Read Description

    Login to post a comment.