As I dive deeper into Go programming, I'm excited to share my learnings on the fundamental building blocks of the language. In this post, we'll explore Go's basic syntax and structure, variables and data types, and constants. These elements form the foundation of any Go program, and understanding them is crucial for mastering the language.

Basic Syntax and Structure

Go programs have a clear and straightforward structure. Let's start with a simple example:

package main

import "fmt"

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

Here's what each part does:

1. package main: Every Go file starts with a package declaration. The main package is special - it defines an executable program rather than a library.

2. import "fmt": This imports the fmt package, which provides formatting and printing functions.

3. func main(): This is the entry point of our program. Execution begins here.

Go uses curly braces {} to define code blocks and doesn't require semicolons at the end of statements (the compiler automatically inserts them).

Variables and Data Types

Go is a statically typed language, which means every variable has a specific type. Let's look at how to declare and use variables:

package main

import "fmt"

func main() {
    // Explicit type declaration
    var name string = "S Soumykanta"
    var year int = 2024
    var isCool bool = true

    // Type inference
    var langName = "golang"

    // Short variable declaration
    myName := "Soumya"

    // Declare first, assign later
    var myNum int
    myNum = 22

    fmt.Println(name, langName, isCool, year, myName, myNum)
}

Go supports several basic data types:

• Strings: For text ("Hello")

• Integers: For whole numbers (42)

• Floats: For decimal numbers (3.14)

• Booleans: For true/false values (true or false)

We can declare variables in multiple ways:

1. Using var with an explicit type

2. Using var with type inference

3. Using the short declaration operator := (only inside functions)

Constants

Constants in Go are values that don't change during the execution of a program. Here's how we work with constants:

package main

import "fmt"

const age = 22
var welcomeMessage string = "Hello World"

func main() {
    const myName string = "S Soumyakanta"
    fmt.Println(myName, age, welcomeMessage)

    // Constant grouping
    const (
        port = 8080
        host = "localhost"
    )

    fmt.Println(port, host)
}

Key points about constants:

1. They're declared using the const keyword.

2. They can be declared inside or outside functions.

3. The value must be known at compile time.

4. We can group related constants together.

Putting It All Together

Let's combine what we've learned into a single program:

package main

import "fmt"

const appVersion = "1.0"

func main() {
    // Variables
    var userName string = "Soumya"
    age := 22
    isLearning := true

    // Constants
    const maxUsers = 100

    // Printing values
    fmt.Println("Welcome to Go fundamentals!")
    fmt.Printf("User: %s, Age: %d\n", userName, age)
    fmt.Printf("Currently learning: %t\n", isLearning)
    fmt.Printf("App version: %s\n", appVersion)
    fmt.Printf("Max users allowed: %d\n", maxUsers)

    // Simple calculation
    x, y := 10, 5
    sum := x + y
    fmt.Printf("Sum of %d and %d is %d\n", x, y, sum)
}

This program demonstrates variable declarations, constant usage, and basic operations, showcasing the simplicity and expressiveness of Go.

As I continue my journey with Go, I'm impressed by its clean syntax and straightforward approach to programming. These fundamentals provide a solid foundation for building more complex applications.