Golang, or Go, is a statically typed, compiled programming language designed for simplicity and efficiency. It is commonly used for backend systems, cloud services, and DevOps tools due to its robust standard library and support for concurrent programming. Go follows a procedural and concurrent programming paradigm, making it ideal for modern computing challenges.

Few things I like about go are

  • The seperation of data (struct) and behavior (methods). This makes the code more readable and maintainable.
  • Easiness to write concurrent code. Go routines and channels are very easy to use and understand.
  • Zero values instead of null. This makes the code more predictable and less error prone.

Few things I dislike about go are

  • The lack of direct support for enums or union types.
  • Lack of collection manipulation features.

Variables

In Go, variables are declared by specifying the type after the variable name. Go also supports type inference using the := syntax.

Syntax and Example:

var a int = 10 // Explicit type declaration
var b, c int = 20, 30 // Multiple variables

const Pi float64 = 3.14 // Constants
const World = "Hello, World" 

x := 42 // type inferred as int
y := "Hello, Go" // type inferred as string

Control Statements

Control statements in Go direct the flow of execution. They include if, else, switch, and looping constructs like for.

Syntax and Example:

// If statement
if x > 0 {
    fmt.Println("x is positive")
}

// For loop
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// Switch statement
switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("OS X.")
case "linux":
    fmt.Println("Linux.")
default:
    fmt.Println(os)
}

Functions

Functions in Go are building blocks that encapsulate code for executing specific tasks. They can take zero or more arguments and return zero or more results.

Syntax and Example:

// Function declaration
func add(x int, y int) int {
    return x + y
}
// Function call
fmt.Println(add(42, 13))

// Anonymous Functions
func main() {
	add := func(x, y int) int {
		return x + y
	}
	fmt.Println(add(1, 1))
}

// function with multiple return values
func vals() (int, int) {
	return 3, 7
}

// Methods or Receiver Functions
type Circle struct {
	x, y, r float64
}
func (c *Circle) area() float64 {
	return math.Pi * c.r*c.r
}
// This is equivalent to
// func area(c *Circle) float64 {
// 	return math.Pi * c.r*c.r
// }

// Variadic Functions
func sum(nums ...int) int {
	total := 0
	for _, num := range nums {
		total += num
	}
	return total
}

Data Structure (Structs)

Structs in Go are collections of fields, used to group data into a single compound type. They are crucial for creating more complex data structures.

Syntax and Example:

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}

// Accessing fields
fmt.Println(p.Name)


// Methods
type Circle struct {
	x, y, r float64
}
// Define a method on the Circle type
func (c *Circle) area() float64 {
	return math.Pi * c.r*c.r
}

// Create a Circle instance and call the method
c := Circle{0, 0, 5}
fmt.Println(c.area())

Interfaces

Interfaces in Go specify method signatures, allowing for dynamic types and polymorphism. They define behavior without implementing it.

Interfaces are contracts which decouple a part of the code from the implementation, It helps with dependency injection and testing.

Syntax and Example:

type DataStore interface {
    Save(data string) error
	Load() (string, error)
}

type SQlite struct{
	db *sql.DB
}

func NewSQlite() DataStore {
	return &SQlite{}
}

func (s *SQlite) Save(data string) error {
	// save data to sqlite
}

func (s *SQlite) Load() (string, error) {
	// load data from sqlite
}

Collection Manipulation

Go provides built-in types for managing collections, such as arrays, slices, and maps.

Syntax and Example:

// Array ( fixed size )
var a [2]string
a[0] = "Hello"
a[1] = "World"

// Slices ( dynamic size )
nums := []int{2, 3, 4}
sum := 0
// Appending to a slice
nums = append(nums, 5)
// Iterating through a slice
for _, num := range nums {
	sum += num
}

// Map
m := make(map[string]int)
m["k1"] = 7
m["k2"] = 13
// Accessing a value from a map
value, ok := m["k2"]
// Iterating through a map
m := map[string]int{"k1": 7, "k2": 13}
for k, v := range m {
	fmt.Println(k, v)
}
// Deleting from a map
delete(m, "k2")

Error Handling

Go handles errors by returning an error value as part of a function’s return values. This approach encourages explicit error checking.

Syntax and Example:

// Function returning an error
func sqrt(x float64) (float64, error) {
    if x < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    return math.Sqrt(x), nil
}

// Error checking when calling the function
result, err := sqrt(-16)
if err != nil {
	fmt.Println(err)
}

Concurrency

Go’s concurrency model is based on goroutines and channels, allowing easy and efficient parallel execution of functions.

Syntax and Example:

func say(s string) {
    for i := 0; i < 5; i++ {
        fmt.Println(s)
    }
}
// Concurrent execution with goroutines
go say("world")

say("hello")

Ecosystem

Installation

Go can be installed from the official website or using package managers like Homebrew.

brew install go

Hello World

package main

import "fmt"

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

Build and Run

# Run the program
go run hello.go

# Build the program
go build hello.go -o hello
./hello

CLI

  • go run <filename.go>: Run the program (for development)
  • go build: Build the program
    • GOOS=linux go build for linux
    • GOOS=windows go build for windows
    • GOOS=darwin go build for mac
  • go test: Run tests
  • go fmt: Format the code

Package Management

  • go mod init <module-name>: Initialize a new module
  • go get <package-name> - Install a package
  • go mod tidy - Update the module file
  • go install - Install the package in the bin directory ( global )

Special Features

  • Go Routines and Channels for Concurrency: Go’s approach to concurrency, with goroutines and channels, allows developers to write concurrent code that is easier to understand and maintain.
  • Interface System: Go’s interface system provides a way to define the behavior of objects, making it easy to use polymorphism without the complexities found in other languages.
  • Static Typing and Type Inference: Go provides the safety of static typing while keeping code concise with type inference.
  • Garbage Collection: Go includes a garbage collector, which provides automatic memory management, reducing the risk of memory leaks and other memory-related errors.