Go Fundamentals - Variables, Types & Basic Syntax

The Bug That Taught Me Go's Type System

Three days into rewriting our API in Go, I hit a bug that made me question everything.

func calculateDiscount(price float64, discount int) float64 {
    return price - (price * discount / 100)
}

result := calculateDiscount(100.50, 15)
fmt.Printf("Final price: $%.2f\n", result)
// Expected: Final price: $85.43
// Got:      Final price: $100.50

The discount wasn't applying. I stared at this for 20 minutes before it hit me: integer division.

In Python, 15 / 100 gives 0.15. In Go, 15 / 100 gives 0 (integer division). The fix was simple once I understood Go's type system:

return price - (price * float64(discount) / 100)
// Now: Final price: $85.43

This moment taught me that Go's explicit type system isn't a burden - it's a feature. The compiler caught what would have been a subtle production bug. This article covers everything I learned about Go's type system the hard way.

---

Variable Declarations: Three Ways

Go has three ways to declare variables. Coming from Python's single name = value syntax, this confused me initially. But each serves a purpose.

1. The var Declaration

var name string
var age int
var isActive bool

fmt.Println(name)     // "" (empty string - zero value)
fmt.Println(age)      // 0 (zero value)
fmt.Println(isActive) // false (zero value)

Key insight: Go initializes all variables to their zero value. No undefined, no null, no surprise NullPointerException.

Zero values by type:

• Numeric types: 0

• Boolean: false

• String: "" (empty string)

• Pointers, slices, maps, channels, functions, interfaces: nil

2. Declaration with Initialization

var name string = "Alice"
var age int = 30
var price float64 = 99.99

But Go infers types, so this is idiomatic:

var name = "Alice"    // inferred as string
var age = 30          // inferred as int
var price = 99.99     // inferred as float64

3. Short Declaration := (Most Common)

name := "Alice"
age := 30
price := 99.99

This is the idiomatic Go way for local variables. Short, clean, type-inferred.

When to use which?

// Use var for package-level variables
var globalConfig = loadConfig()

func processUser() {
    // Use := for local variables
    user := fetchUser()
    email := user.Email
    
    // Use var when you need zero value
    var count int  // starts at 0
    
    // Use var for explicit type when inference isn't clear
    var timeout time.Duration = 30 * time.Second
}

Multiple Declarations

// Declare multiple variables
var x, y, z int
var name, email string

// Declare and initialize
var x, y = 1, 2
var name, age = "Alice", 30

// Short form (most common)
x, y := 1, 2
name, age := "Alice", 30

// Group declarations
var (
    name  string
    age   int
    email string
)

---

Basic Types

Numeric Types

Go has 11 numeric types. This seemed excessive coming from Python's simple int and float.

// Integers
var i8  int8   // -128 to 127
var i16 int16  // -32768 to 32767
var i32 int32  // -2^31 to 2^31-1
var i64 int64  // -2^63 to 2^63-1

// Unsigned integers
var u8  uint8  // 0 to 255
var u16 uint16 // 0 to 65535
var u32 uint32 // 0 to 2^32-1
var u64 uint64 // 0 to 2^64-1

// Platform-dependent (32 or 64 bit)
var i int      // Most common - use this by default
var u uint

// Floating point
var f32 float32
var f64 float64  // Use this by default

// Complex numbers (yes, built-in!)
var c64  complex64
var c128 complex128

Real-world lesson: I started using int32 everywhere because our database IDs were 32-bit integers. Then I hit this:

id := 12345                 // type: int
var dbID int32 = id         // Error: cannot use id (type int) as type int32

Solution: Use int by default. Convert only when interfacing with external systems:

id := 12345
dbID := int32(id)           // Explicit conversion

String Type

name := "Alice"
multiline := `This is a
multi-line string
using backticks`

// Strings are immutable
greeting := "Hello"
// greeting[0] = 'h'  // Error: cannot assign to greeting[0]

// String concatenation
fullName := "Alice" + " " + "Smith"

// String length
fmt.Println(len("Hello"))  // 5

// String indexing (gives byte, not character!)
s := "Hello"
fmt.Println(s[0])  // 72 (ASCII value of 'H')

UTF-8 gotcha I learned the hard way:

emoji := "Hello 👋"
fmt.Println(len(emoji))     // 10 (not 7!)
// len() returns bytes, not characters

For Unicode-aware operations, use the unicode/utf8 package:

import "unicode/utf8"

emoji := "Hello 👋"
fmt.Println(utf8.RuneCountInString(emoji))  // 7

Boolean Type

var isActive bool = true
var isComplete = false
isDone := true

// No truthy/falsy values like JavaScript or Python
// if count { }  // Error: non-bool used as condition
// Must be explicit
if count > 0 {
    // do something
}

---

Type Conversions (No Implicit Conversions!)

This is where Go differs dramatically from Python or JavaScript:

var i int = 42
var f float64 = i          // Error: cannot use i (type int) as type float64
var f float64 = float64(i) // Correct: explicit conversion

var x int32 = 100
var y int64 = x            // Error: cannot use x (type int32) as type int64
var y int64 = int64(x)     // Correct

Real example from my code:

// Calculating percentage
total := 100        // int
completed := 75     // int

// This was wrong:
// percentage := completed / total * 100  // Always 0 (integer division)

// Correct:
percentage := float64(completed) / float64(total) * 100
fmt.Printf("%.1f%%\n", percentage)  // 75.0%

Common Conversions

// String to int
s := "123"
i, err := strconv.Atoi(s)
if err != nil {
    // Handle error
}

// Int to string
num := 42
str := strconv.Itoa(num)  // "42"

// String to float
f, err := strconv.ParseFloat("3.14", 64)

// Float to string
s := strconv.FormatFloat(3.14159, 'f', 2, 64)  // "3.14"

// Format with Sprintf (easier for simple cases)
str := fmt.Sprintf("%d", 42)        // "42"
str := fmt.Sprintf("%.2f", 3.14159) // "3.14"

---

Constants

Constants are declared with const and must be compile-time values:

const Pi = 3.14159
const AppName = "MyApp"
const MaxConnections = 100

// Multiple constants
const (
    StatusOK       = 200
    StatusNotFound = 404
    StatusError    = 500
)

// Typed constants
const Pi float64 = 3.14159
const MaxRetries int = 3

Untyped Constants (Powerful Feature)

const x = 42  // Untyped constant

var i int = x
var f float64 = x
var c complex128 = x

// All work! The constant adapts to the type

This is useful in APIs:

const Timeout = 30  // Untyped

var seconds int = Timeout
var duration time.Duration = Timeout * time.Second

The iota Enumerator

iota creates incrementing constants - perfect for enumerations:

const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

// Skip values
const (
    _  = iota  // Skip 0
    KB = 1 << (10 * iota)  // 1024
    MB                      // 1048576
    GB                      // 1073741824
)

// Custom expressions
const (
    Read = 1 << iota  // 1 (binary: 001)
    Write             // 2 (binary: 010)
    Execute           // 4 (binary: 100)
)

permissions := Read | Write  // 3 (binary: 011)

Real-world usage from my API:

const (
    RoleGuest = iota     // 0
    RoleUser             // 1
    RoleModerator        // 2
    RoleAdmin            // 3
)

// Check permissions
if user.Role >= RoleModerator {
    // Allow action
}

---

Type Inference and Type Aliases

Type Inference

// Go infers the type
name := "Alice"           // string
count := 42               // int
price := 99.99            // float64
isActive := true          // bool
items := []string{}       // slice of strings
config := map[string]int{} // map

// Inference from function returns
result := calculateTotal()  // Type depends on function return

Type Aliases

type UserID int
type Email string

var id UserID = 12345
var email Email = "[email protected]"

// Type safety
var regularInt int = id  // Error: cannot use id (type UserID) as type int
var regularInt int = int(id)  // Correct: explicit conversion

Why use type aliases? They add semantic meaning:

// Before: Confusing
func createUser(id int, referrerID int) error {
    // Which ID is which?
}

// After: Clear
type UserID int

func createUser(id UserID, referrerID UserID) error {
    // Clear!
}

---

Zero Values: A Safety Feature

Every variable has a zero value. This prevents undefined behavior:

var i int       // 0
var f float64   // 0.0
var s string    // ""
var b bool      // false
var ptr *int    // nil
var slice []int // nil
var m map[string]int // nil

// You can safely check without initialization
var count int
if count == 0 {
    // Always safe
}

var name string
if name == "" {
    // Always safe
}

Real bug I caught with zero values:

// Python habit: uninitialized variable would crash
// Go: works, but wrong logic

var retryCount int
// Forgot to initialize, but code runs
if retryCount > 0 {  // Always false initially
    // This never executes on first run
}

The bug was subtle: the code ran but had wrong logic. Zero values are safe but require thinking about default states.

---

Practical Example: Building a Config Parser

Here's real code from my first Go project - parsing environment config:

package main

import (
    "fmt"
    "os"
    "strconv"
)

// Use type aliases for clarity
type Port int
type Timeout int

// Configuration struct
var (
    AppName    = getEnv("APP_NAME", "MyApp")
    ServerPort = getEnvInt("PORT", 8080)
    DebugMode  = getEnvBool("DEBUG", false)
    Timeout    = getEnvInt("TIMEOUT", 30)
)

func main() {
    fmt.Printf("Starting %s\n", AppName)
    fmt.Printf("Port: %d\n", ServerPort)
    fmt.Printf("Debug: %t\n", DebugMode)
    fmt.Printf("Timeout: %ds\n", Timeout)
}

func getEnv(key, defaultValue string) string {
    value := os.Getenv(key)
    if value == "" {
        return defaultValue
    }
    return value
}

func getEnvInt(key string, defaultValue int) int {
    value := os.Getenv(key)
    if value == "" {
        return defaultValue
    }
    
    intValue, err := strconv.Atoi(value)
    if err != nil {
        return defaultValue
    }
    return intValue
}

func getEnvBool(key string, defaultValue bool) bool {
    value := os.Getenv(key)
    if value == "" {
        return defaultValue
    }
    
    boolValue, err := strconv.ParseBool(value)
    if err != nil {
        return defaultValue
    }
    return boolValue
}

Usage:

# With defaults
go run main.go
# Starting MyApp
# Port: 8080
# Debug: false
# Timeout: 30s

# With environment variables
PORT=3000 DEBUG=true go run main.go
# Starting MyApp
# Port: 3000
# Debug: true
# Timeout: 30s

---

Common Mistakes I Made

1. Unused Variables

func processData() {
    count := 0
    name := "Alice"
    // Error: count declared but not used
    fmt.Println(name)
}

Solution: Go forces you to use or remove variables. Use _ to explicitly ignore:

result, _ := someFunction()  // Ignore second return value

2. Short Declaration Scope

if value := getValue(); value > 10 {
    fmt.Println(value)  // OK
}
fmt.Println(value)  // Error: value not defined

Variables declared in if are scoped to that block.

3. Shadowing Variables

count := 5
if true {
    count := 10  // New variable! Shadows outer count
    fmt.Println(count)  // 10
}
fmt.Println(count)  // Still 5!

This caused a bug in my code. The fix: don't redeclare, just assign:

count := 5
if true {
    count = 10  // Assignment, not declaration
    fmt.Println(count)  // 10
}
fmt.Println(count)  // 10

4. Integer Division Surprise

// Wrong
average := total / count  // Integer division if both are ints

// Right
average := float64(total) / float64(count)

---

Your Challenge

Build a simple calculator that handles different numeric types:

package main

import "fmt"

func main() {
    // Implement these functions
    sum := add(10, 20)
    difference := subtract(50.5, 20.3)
    product := multiply(5, 6.5)
    quotient := divide(100, 3)
    
    fmt.Printf("Sum: %d\n", sum)
    fmt.Printf("Difference: %.2f\n", difference)
    fmt.Printf("Product: %.2f\n", product)
    fmt.Printf("Quotient: %.2f\n", quotient)
}

// Implement these functions with proper type handling

Try handling type conversions, return types, and error cases (like division by zero).

---

Key Takeaways

1. Three declaration styles: var, var =, and := - use := for local variables

2. Zero values: Every variable is initialized - no undefined behavior

3. No implicit conversions: Explicit is better than implicit

4. Type aliases: Add semantic meaning to primitive types

5. Constants and iota: Powerful enumeration support

6. Go is strict: Unused variables, type mismatches are compile errors - catches bugs early

---

What I Learned

Coming from Python, Go's type system felt restrictive. But after shipping production code:

• Explicit conversions prevented the discount calculation bug

• Zero values eliminated null/undefined checks

• Type safety caught integration bugs at compile time

• Unused variable errors kept code clean

The type system isn't fighting you - it's catching bugs before they reach production.

---

Next: Control Structures

In the next article, we'll explore Go's control flow: if/else, switch, loops, and the powerful defer statement. You'll learn how Go's simpler approach to control structures actually makes code more readable.