Skip to main content

Comprehensive Golang Syllabus

Introduction to Go​

Overview of Go​

Setting up the Go Environment​

  • Installing Go
  • Go workspace setup (GOPATH, GOROOT)
  • Go Modules
  • Running a Go program

Go CLI Basics​

  • go run, go build, go fmt
  • go get, go mod
  • go test, go generate

Go Language Basics​

Basic Syntax​

  • Structure of a Go program
  • Comments and documentation strings

Primitive Data Types and Constants​

  • Integers, floats, booleans, strings
  • Constants: Typed and untyped

Variables and Type Inference​

  • Declaration: var and shorthand :=
  • Type inference and zero values

Basic I/O​

  • fmt package (Println, Printf, Scan, etc.)

Control Flow​

  • Conditionals: if, else, switch
  • Loops: for, break, continue, range
  • goto, labels, and fallthrough

Advanced Data Structures​

Arrays and Slices​

  • Declaration, slicing, capacity, and resizing
  • Built-in functions: len(), cap(), append()
  • Multidimensional arrays and slices

Maps​

  • Declaration, initialization, adding, retrieving, deleting
  • Iterating over maps
  • Maps as sets

Structs​

  • Declaration and initialization
  • Embedded structs (Composition)
  • Methods on structs
  • Tags in structs (useful in JSON/XML marshaling)

Pointers​

  • Declaration and dereferencing
  • Pointers to structs
  • Nil pointers and pointer arithmetic
  • Passing by reference vs. value

Functions in Go​

Basic Functions​

  • Declaration, parameters, and return values
  • Named return values
  • Variadic functions

First-Class Functions​

  • Functions as variables and parameters
  • Closures and anonymous functions
  • Higher-order functions

Recursion​

Defer, Panic, and Recover​

  • Usage of defer in cleanup
  • panic and when to use it
  • Error recovery with recover

Concurrency in Go​

Goroutines​

  • Creating and running goroutines
  • Goroutines and the Go runtime scheduler
  • Synchronization issues with goroutines

Channels​

  • Creating and using channels
  • Buffered vs unbuffered channels
  • Channel operations: send, receive, close
  • Channel directions and blocking behavior

Channel Patterns​

  • Select statement and timeout
  • Fan-in, Fan-out, and Pipeline patterns

Concurrency Primitives​

  • Mutexes, RWMutex
  • WaitGroups, Atomic operations
  • Condition Variables
  • Worker Pools and Semaphore Patterns

Go's Memory Model​

  • Happens-before relation
  • Avoiding race conditions
  • Using the race detector

Object-Oriented Patterns in Go​

Interfaces​

  • Defining and implementing interfaces
  • Implicit implementation
  • Empty interfaces and type assertions
  • Interface vs Struct usage
  • Practical use cases: Dependency injection, mock testing

Polymorphism​

  • Implementing multiple interfaces
  • Interface embedding

Composition over Inheritance​

  • Composition in structs and interfaces
  • Real-world design patterns using composition

Error Handling and Logging​

Idiomatic Error Handling​

  • Returning errors vs. using panic
  • Creating custom error types
  • Wrapping errors using fmt.Errorf()

Error Handling Patterns​

  • Sentinel errors
  • Error propagation
  • Error handling in critical applications

Logging​

  • The log package
  • Customizing log formats and levels
  • Structured logging (with external libraries)

Third-Party Logging Libraries​

  • Logrus, Zap, etc.

Testing and Benchmarking​

Unit Testing​

  • Writing test cases using the testing package
  • Test functions (TestXxx)
  • Using go test and test flags
  • Table-driven tests

Mocking and Dependency Injection for Tests​

  • Using interfaces for testing
  • Third-party mocking libraries

Benchmarking​

  • Writing benchmarks (BenchmarkXxx)
  • Performance profiling (pprof, memory, CPU)

Code Coverage​

  • Measuring coverage
  • Tools like go tool cover

Fuzz Testing​

  • Using fuzz testing for inputs

Memory Management​

Understanding Go's Garbage Collector​

  • How Go's GC works
  • Tuning the garbage collector

Manual Memory Management​

  • Stack vs heap memory
  • Memory profiling tools
  • Object reuse and pooling

Go Modules and Dependency Management​

Go Modules​

  • What is a Go module?
  • Module initialization and versioning
  • Private modules and vendoring

Dependency Management​

  • Managing dependencies via go mod
  • Semantic import versioning

File Handling and OS Interaction​

File I/O​

  • Reading from and writing to files
  • Handling file paths
  • Working with directories and file permissions

Interacting with the OS​

  • Using the os package
  • Command-line arguments
  • Environment variables

Networking in Go​

Basic Networking​

  • Creating TCP and UDP servers and clients
  • Working with the net/http package for HTTP
  • Working with WebSockets

Building REST APIs​

  • Designing and implementing RESTful services using net/http
  • Context handling in requests
  • Middleware and routing libraries (e.g., Gorilla Mux)

gRPC and Protocol Buffers​

  • Introduction to gRPC
  • Implementing gRPC clients and servers
  • Using Protocol Buffers for message serialization

Go in Cloud-Native and Microservices​

Building Microservices in Go​

  • Structuring a microservices architecture
  • Inter-service communication: gRPC, REST, etc.
  • Error handling in distributed systems

Containerization with Docker​

  • Dockerizing Go applications
  • Multistage builds and optimizing images

Deploying Go Applications​

  • CI/CD for Go
  • Kubernetes basics for Go deployments
  • Service discovery, load balancing, and scaling in cloud-native Go apps

Go Optimization and Performance Tuning​

Profiling and Tracing​

  • CPU and memory profiling
  • Tracing system calls, goroutines, etc.

Optimizing Go Applications​

  • Memory optimizations and GC tuning
  • Avoiding common pitfalls
  • Optimizing concurrency and parallelism

Go Best Practices​

Code Organization​

  • Package structure and best practices
  • Naming conventions and idiomatic Go

Writing Efficient Go Code​

  • Avoiding global state
  • Immutable data structures
  • Efficient use of Goroutines and Channels

Documentation​

  • Using go doc for self-documenting code
  • Writing effective documentation comments

Security Best Practices​

  • Handling sensitive data
  • Securing APIs and services