Environment and OS

🏠 Your Program’s Home: Environment and OS in Go

Imagine your Go program is like a little person living in a house. The house is your computer. Just like you know things about your home—where the door is, what’s in the fridge, where to find the light switch—your program can learn things about its home too!

🌟 The Big Picture: What Are We Learning?

Today, we’re going to explore three super cool things:

1. Environment and Arguments – How your program reads notes left for it and listens to instructions
2. os.Exit – How your program says “I’m done!” and leaves
3. Environment Configuration – How your program finds secret settings

Think of it like this: You’re teaching your program to read sticky notes, listen to what people tell it, and know when to go home.

📬 Part 1: Environment and Arguments

The Mailbox: Environment Variables

Imagine your computer has a mailbox full of sticky notes. Each note has a name and a message. These are called Environment Variables.

package main

import (
    "fmt"
    "os"
)

func main() {
    // Read a sticky note called "HOME"
    home := os.Getenv("HOME")
    fmt.Println("Your home is:", home)
}

What’s happening?

• os.Getenv("HOME") looks in the mailbox for a note named “HOME”
• It returns whatever message is written on it
• If no note exists, it returns an empty string ""

Reading All the Sticky Notes

Want to see ALL the notes at once? Easy!

package main

import (
    "fmt"
    "os"
)

func main() {
    // Get ALL sticky notes
    notes := os.Environ()

    for _, note := range notes {
        fmt.Println(note)
    }
}

Each note looks like: NAME=value (like PATH=/usr/bin)

The Command Line: Arguments

Now imagine someone yelling instructions at your program when it starts. These are Command Line Arguments.

package main

import (
    "fmt"
    "os"
)

func main() {
    // os.Args is like a list of words
    // The first word is always the program name

    fmt.Println("Program name:", os.Args[0])

    if len(os.Args) > 1 {
        fmt.Println("First instruction:", os.Args[1])
    }
}

Run it like this:

go run main.go hello world

What you get:

• os.Args[0] = the program name
• os.Args[1] = “hello”
• os.Args[2] = “world”

graph TD
    A["You run: go run main.go hello world"] --> B["os.Args gets filled"]
    B --> C["os.Args[0] = program name"]
    B --> D["os.Args[1] = hello"]
    B --> E["os.Args[2] = world"]

A Friendly Greeter Program

Let’s make something fun!

package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Hey! Tell me your name!")
        fmt.Println("Use: go run main.go YourName")
        return
    }

    name := os.Args[1]
    fmt.Printf("Hello, %s! Nice to meet you!\n", name)
}

🚪 Part 2: os.Exit - Saying Goodbye

Every program needs to end eventually. It’s like leaving a room. os.Exit is how your program says “I’m done!”

The Exit Code: A Report Card

When your program leaves, it holds up a number. This number tells everyone how things went:

Using os.Exit

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println("Starting my program...")

    // Something went wrong!
    if somethingBad := true; somethingBad {
        fmt.Println("Oh no! Problem detected!")
        os.Exit(1) // Exit with error code 1
    }

    fmt.Println("This line never runs!")
}

IMPORTANT: When you call os.Exit():

• Your program stops immediately
• No more code runs after it
• Any cleanup code gets skipped!

A Safety Check Program

package main

import (
    "fmt"
    "os"
)

func main() {
    // Check if a required file exists
    filename := "config.txt"

    _, err := os.Stat(filename)
    if err != nil {
        fmt.Println("ERROR: Config file missing!")
        os.Exit(1)
    }

    fmt.Println("Config found! Starting...")
    // ... rest of program

    os.Exit(0) // Success!
}

graph TD
    A["Program Starts"] --> B{Check for config.txt}
    B -->|File exists| C["Continue running"]
    C --> D["Do work..."]
    D --> E["os.Exit#40;0#41; - Success!"]
    B -->|File missing| F["Print error message"]
    F --> G["os.Exit#40;1#41; - Failure!"]

The Golden Rule of os.Exit

Remember: os.Exit is like hitting the emergency stop button. Use it wisely!

When to use os.Exit:

• When something really bad happens
• When your program is completely done
• In the main function (not in libraries!)

When NOT to use os.Exit:

• Inside functions that others might use
• When you could return an error instead

⚙️ Part 3: Environment Configuration

Now let’s combine what we learned! Programs often need settings. Instead of hardcoding values, smart programs read them from the environment.

Why Environment Variables for Config?

Imagine you have a program that talks to a database. The database address might be different:

• On your laptop: localhost
• On the test server: test.database.com
• On the real server: prod.database.com

Instead of changing your code for each place, you read it from the environment!

Building a Configurable Program

package main

import (
    "fmt"
    "os"
)

func main() {
    // Read configuration from environment
    dbHost := getEnvOrDefault("DB_HOST", "localhost")
    dbPort := getEnvOrDefault("DB_PORT", "5432")
    appMode := getEnvOrDefault("APP_MODE", "development")

    fmt.Println("Database Host:", dbHost)
    fmt.Println("Database Port:", dbPort)
    fmt.Println("App Mode:", appMode)
}

// Helper: Get env variable or use default
func getEnvOrDefault(key, defaultVal string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultVal
}

Setting Environment Variables

On Linux/Mac:

export DB_HOST=myserver.com
export DB_PORT=3306
go run main.go

On Windows:

set DB_HOST=myserver.com
set DB_PORT=3306
go run main.go

Checking If a Variable Exists

Sometimes you need to know: “Is this note in the mailbox, or just empty?”

package main

import (
    "fmt"
    "os"
)

func main() {
    // LookupEnv tells you if the variable exists
    apiKey, exists := os.LookupEnv("API_KEY")

    if !exists {
        fmt.Println("WARNING: API_KEY is not set!")
        fmt.Println("Using demo mode...")
    } else if apiKey == "" {
        fmt.Println("WARNING: API_KEY is empty!")
    } else {
        fmt.Println("API_KEY found! Ready to go!")
    }
}

graph TD
    A["os.LookupEnv#40;key#41;"] --> B{Does variable exist?}
    B -->|Yes| C{Is it empty?}
    B -->|No| D["exists = false"]
    C -->|Yes| E["value = '', exists = true"]
    C -->|No| F["value = 'something', exists = true"]

Setting Variables From Your Program

Your program can also write sticky notes!

package main

import (
    "fmt"
    "os"
)

func main() {
    // Set an environment variable
    os.Setenv("MY_APP_VERSION", "1.0.0")

    // Read it back
    version := os.Getenv("MY_APP_VERSION")
    fmt.Println("Running version:", version)

    // Remove it when done
    os.Unsetenv("MY_APP_VERSION")
}

🎯 Putting It All Together

Here’s a complete example that uses everything we learned:

package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    // 1. Check command line arguments
    if len(os.Args) < 2 {
        showHelp()
        os.Exit(0)
    }

    command := os.Args[1]

    // 2. Read configuration from environment
    appName := getEnvOrDefault("APP_NAME", "MyApp")
    debugMode := os.Getenv("DEBUG") == "true"

    if debugMode {
        fmt.Println("[DEBUG] Running in debug mode")
        fmt.Println("[DEBUG] App name:", appName)
    }

    // 3. Handle commands
    switch strings.ToLower(command) {
    case "greet":
        name := getEnvOrDefault("USER_NAME", "Friend")
        fmt.Printf("Hello from %s, %s!\n", appName, name)
        os.Exit(0)

    case "status":
        fmt.Println("All systems operational!")
        os.Exit(0)

    default:
        fmt.Println("Unknown command:", command)
        os.Exit(1)
    }
}

func showHelp() {
    fmt.Println("Usage: program [command]")
    fmt.Println("Commands:")
    fmt.Println("  greet  - Say hello")
    fmt.Println("  status - Check status")
}

func getEnvOrDefault(key, defaultVal string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultVal
}

📝 Quick Reference

🌈 You Did It!

You just learned how your Go programs can:

• 📬 Read sticky notes (environment variables) from the computer
• 🗣️ Listen to instructions (command line arguments)
• 🚪 Leave properly (os.Exit with the right code)
• ⚙️ Configure themselves without changing code

Your programs are now like smart helpers that can adapt to any home they’re placed in!

Next Steps: Try building a small CLI tool that reads settings from environment variables. Maybe a simple calculator or a file organizer!

Remember: Every expert was once a beginner. You’re doing amazing! 🚀