Hello Golang: My First Steps to the Language

1. Go’s Nature

• Static typing: Go checks types at compile time, not runtime — catching many errors early before your code ever runs. Despite being statically typed, Go’s type inference (:=) keeps syntax concise.
• Compiled: When you run go build, your entire program (including dependencies) compiles into one static binary. No virtual machine, no interpreter, no dependency hell, just a single executable that runs anywhere.
• Memory management: Go provides automatic garbage collection like Java or Python, but it’s optimized for low latency.
• Concurrency: Go’s signature feature makes it simple to handle multiple tasks at once.
• Simplicity by design: Go avoids complexity: no inheritance, no implicit behavior, no hidden magic. Everything is explicit, predictable, and easy to read.
• Composition over inheritance: Instead of class hierarchies, Go encourages small, composable types you can combine freely.
• First-class tooling: Tools like gofmt, go test, and go mod are part of the language itself, enforcing consistency and speeding up development.

2. Setting Up the Environment

// language: bash
go version

// language: bash
mkdir myfirstgo && cd myfirstgo
go mod init myfirstgo

// language: bash
go run main.go

// language: bash
go build

3. Variables

Variables

// language: go
var message string = "Hello, Go!"
count := 3 // inferred type: int

• Integers (int, int64)
• Floating-point numbers (float32, float64)
• Strings (string)
• Booleans (bool)

4. Data Collections

Array

// language: go
var nums [3]int
nums[0] = 10
nums[1] = 20
nums[2] = 30

fmt.Println(nums) // [10 20 30]

// language: go
arr := [3]string{"Go", "Rust", "Python"}
fmt.Println(arr[1]) // Rust

Slice

// language: go
langs := []string{"Go", "Ruby"}
langs = append(langs, "Python")

fmt.Println(langs) // [Go Ruby Python]
fmt.Println(len(langs)) // 3

// language: go
nums := []int{10, 20, 30, 40, 50}
fmt.Println(nums[1:4]) // [20 30 40]

Map

// language: go
scores := map[string]int{
  "Alice": 90,
  "Bob":   85,
}

fmt.Println(scores["Alice"]) // 90

// Add new value
scores["Charlie"] = 92

// Check existence
value, ok := scores["Bob"]
if ok {
  fmt.Println("Bob's score is", value)
}

// language: go
delete(scores, "Alice")

5. Control Flow

// language: go
if x > 0 {
  fmt.Println("positive")
} else if x < 0 {
  fmt.Println("negative")
} else {
  fmt.Println("zero")
}

// language: go
switch day := "saturday"; day {
case "saturday", "sunday":
  fmt.Println("Weekend")
default:
  fmt.Println("Weekday")
}

// language: go
for i := 0; i < 5; i++ {
  fmt.Println(i)
}

// language: go
langs := []string{"Go", "Ruby", "Python"}
for index, value := range langs {
  fmt.Println(index, value)
}

6. Functions

// language: go
func add(a int, b int) int {
  return a + b
}

// language: go
func divide(a, b float64) (float64, error) {
  if b == 0 {
    return 0, fmt.Errorf("division by zero")
  }
  return a / b, nil
}

func main() {
  result, err := divide(10, 0)
  if err != nil {
    fmt.Println("Error:", err)
  }
}

Pass by Value and Reference

// language: go
func modifyArray(arr [3]int) {
  arr[0] = 99
}

func modifySlice(slice []int) {
  slice[0] = 99
}

func main() {
  numsArray := [3]int{1, 2, 3}
  modifyArray(numsArray)
  fmt.Println(numsArray) // [1 2 3] — unchanged

  numsSlice := []int{1, 2, 3}
  modifySlice(numsSlice)
  fmt.Println(numsSlice) // [99 2 3] — changed
}

7. Modules and Packages

myfirstgo/
 ├── main.go
 └── utils/
     └── math.go

// language: go
package utils

func Square(x int) int {
  return x * x
}

// language: go
package main

import (
  "fmt"
  "myfirstgo/utils"
)

func main() {
  fmt.Println(utils.Square(5))
}

• Exported identifiers (visible outside their package) start with a capital letter.
• Unexported identifiers (private to the same package) start with a lowercase letter.

// language: go
package utils

// Exported: accessible from other packages
func Add(a, b int) int {
  return a + b
}

// Unexported: only usable inside the utils package
func subtract(a, b int) int {
  return a - b
}

8. Start Solving a Simple LeetCode Problem with Go

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
You may assume that each input would have exactly one solution, and you may not use the same element twice.
You can return the answer in any order.

Example 1:
Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

// language: go
func twoSum(nums []int, target int) []int {
    // key is number, value is index
    numMap := map[int]int{}

    for index, num := range nums {
        rest := target - num
        if numMap[rest] != nil {
            return []int{index, numMap[rest]}
        }

        numMap[num] = index
    }

    return []int{}
}

• numMap[rest] returns an int, so comparing it to nil is invalid (since I'm familiar with JavaScript). Go uses this syntax

// language: go
if value, ok := numMap[rest]; ok {
    // do sth
}

• Return return {index, restIndex} is invalid, it should be []int{index, restIndex}

// language: go
func twoSum(nums []int, target int) []int {
    // key is number, value is index
    numMap := make(map[int]int)

    for index, num := range nums {
        rest := target - num
        if restIndex, ok := numMap[rest]; ok {
            return []int{index, restIndex}
        }

        numMap[num] = index
    }

    return []int{}
}