Learning Objectives

By the end of this course, participants will be able to:

• understand the core concepts and structure of Go programming
• define and use functions, methods, and interfaces
• apply Go’s error handling model effectively
• build concurrent systems using goroutines and channels
• apply advanced concurrency patterns and synchronisation techniques
• work with packages, modules, and build tooling
• test and debug Go applications
• build HTTP-based services and integrate with external data sources
• understand differences between REST (HTTP/JSON) and gRPC/Protobuf

Course Content

Part 1 – Go Fundamentals and Core Language

Participants begin by understanding the structure and philosophy of Go.

Getting Started with Go

Topics typically include:

• key differences between Go and other modern languages
• approaches to data definition and object modelling
• setting up the Go toolchain and development environment (e.g. VSCode)
• writing, building, and running a Hello World application
• structure of a typical Go program

Core Elements of Go Programming

Topics typically include:

• tokens, variables, and assignments
• short variable declarations
• arithmetic operators and constants
• pointers and strings
• formatted output using fmt.Printf()
• relational, logical, and bitwise operators

Control Flow in Go

Topics typically include:

• conditional statements (if, else, else if)
• switch statements (expression and type switches)
• loop constructs (for, nested loops, while-style loops)
• break, continue, and goto

Data Types and Data Structures

Topics typically include:

• Go data types
• arrays, slices, and maps
• working with ranges and collections
• container types (lists, rings)

Functions in Go

Topics typically include:

• defining and calling functions
• parameters (single, multiple, variadic)
• returning values
• call by reference
• anonymous functions and closures
• deferred execution
• panic and recover mechanisms
• recursion and higher-order functions

Structs and Data-Oriented Programming

Topics typically include:

• defining and initialising structs
• struct variables and comparisons
• passing structs to functions
• constructor-style patterns
• JSON serialisation
• anonymous structs and adding behaviour

Part 2 – Intermediate Go: Key Differentiators

Participants explore what makes Go distinct from other languages.

Error Handling in Go

Topics typically include:

• idiomatic error handling patterns
• creating and returning custom error types

Concurrency in Go

Topics typically include:

• goroutines and channels
• synchronising concurrent execution
• advanced concurrency patterns:
• channel synchronisation and timeouts
• non-blocking operations
• worker pools and rate limiting
• atomic counters, mutexes, and pooling
• stateful goroutines and condition variables

Interfaces in Go

Topics typically include:

• defining and implementing interfaces
• built-in interfaces (e.g. Stringer)
• empty interface (interface{})
• embedded types and composition
• comparison of Go interfaces vs generics in other languages

Low-Level Programming Concepts

Topics typically include:

• unsafe pointers
• bitwise operations
• data alignment and memory layout
• calling C from Go

Part 3 – Development and Build Tooling

Participants learn how to structure and manage Go projects.

Packages and Modules

Topics typically include:

• importing and defining packages
• working with custom packages
• introduction to Go modules

Developer Productivity and Lifecycle

Topics typically include:

• testing in Go (unit tests, benchmarks, examples)
• debugging using VSCode extensions
• managing the development lifecycle

Part 4 – Real-World Go Applications

Participants apply their knowledge to real-world scenarios.

File Handling

Topics typically include:

• working with files and directories
• reading and writing files
• temporary files and file paths

Service Development and Integration

Topics typically include:

• building HTTP/JSON RESTful services (e.g. Gorilla/MUX)
• comparing REST with gRPC and Protobuf
• implementing a simple gRPC client/server

Integrating with External Data Providers

Topics typically include:

• working with relational databases (e.g. PostgreSQL)
• implementing CRUD operations
• considerations for NoSQL data providers

Delivery Approach

This is a fast-paced, hands-on programme designed for experienced developers.

It includes:

• instructor-led sessions with real-world context
• practical demonstrations and exercises
• downloadable example code
• application of concepts to real service-based systems

Duration

3 Days

Delivery Options

This course can be delivered as:

• a public scheduled course
• a private team programme
• virtual delivery
• on-site classroom training

Outcomes

After completing this course, participants will be able to:

• develop structured and efficient Go applications
• apply Go’s concurrency model to real-world problems
• build scalable services and microservices
• integrate with external systems and data providers
• test, debug, and manage Go code effectively
• transition confidently from other languages into Go

Additional Notes

This course is particularly valuable for teams adopting Go for:

• microservices and distributed systems
• cloud-native and backend development
• high-performance service architectures

Participants benefit most when they bring prior development experience, enabling them to quickly apply Go concepts to real-world scenarios.