Home>Courses>Advanced Techniques in Go Programming

Advanced Techniques in Go Programming

Gain insights into Go's concurrency model with goroutines and channels. Explore advanced concepts like interfaces, testing, and build highly concurrent systems like web and RESTful servers.

Intermediate

329 Lessons

70h

Certificate of Completion

Gain insights into Go's concurrency model with goroutines and channels. Explore advanced concepts like interfaces, testing, and build highly concurrent systems like web and RESTful servers.

AI-POWERED

Explanations

AI-POWERED

Explanations

This course includes

324 Playgrounds

13 Quizzes

Course Overview

What You'll Learn

Course Content

Recommendations

Course Overview

Go is one of the most popular programming languages today in the systems programming and networking space. Go has built-in concurrency capabilities using a simple concurrency model implemented using goroutines and channels. In addition to Go’s rich and reliable standard library, handy Go packages (cobra and viper) allow us to develop powerful command-line utilities (e.g., docker and hugo) in Go. You will start the course by covering the basics of Go—syntax, basic and composite data types, etc.—before movin...Show More

Go is one of the most popular programming languages today in the systems programming and networking space. Go has built-in concu...Show More

TAKEAWAY SKILLS

Distributed Computing

Concurrency

RESTful API

REST API

What You'll Learn

Familiarity with the core features of the Go language

Hands-on experience with developing Go functions and packages

Thorough understanding of advanced Go features such as reflection, interfaces, and generics

Ability to design and develop feature-rich Windows and UNIX utilities and system tools in Go

Hands-on experience with designing highly concurrent applications in Go

Ability to build REST, gRPC, and WebSocket-based servers and clients in Go

Familiarity with the core features of the Go language

Course Content

Course Introduction

1 Lessons

Get familiar with advanced Go, including RESTful services, WebSocket protocol, and generics.

Course Overview

Introduction to Go

19 Lessons

Look at Go’s advantages, syntax, variables, iteration, control structures, concurrency, and practical applications.

A Quick Introduction to Go

The Advantages of Go

Accessing Go Documentation

Writing Our First Program

Running Go Code

Important Characteristics of Go: Variables

Important Characteristics of Go: Control

Important Characteristics of Go: Loops

Important Characteristics of Go: Getting User Input

Important Characteristics of Go: Error Variables

Important Characteristics of Go: Concurrency Model

Developing the which(1) Utility in Go

Logging Information I

Logging Information II

Overview of Go Generics

Developing a Basic Phone Book Application

Exercise: Introduction to Go

Solution: Introduction to Go

Recap: Introduction to Go

Basic Go Data Types

26 Lessons

Explore Go's basic data types, including numerics, strings, errors, and data structures.

Introduction

The error Data Type

Numeric Data Types

Non-Numeric Data Types

Integer Conversions: Unicode vs. String Values

The strings Package

Times and Dates

A Utility for Parsing Dates and Times

Working with Different Time Zones

Go Constants

Slice: Length and Capacity

Selecting a Part of a Slice

Byte Slices

Deleting an Element from a Slice

Connection Between Slices and Arrays

The copy() Function

Sorting Slices

Pointers

Generating Random Numbers

Generating Random Strings

Generating Secure Random Numbers

Updating the Phone Book Application

Exercise: Basic Go Data Types

Solution: Basic Go Data Types

Recap: Basic Go Data Types

Composite Data Types

17 Lessons

Grasp the fundamentals of using composite data types, patterns, and CSV file handling in Go.

Regular Expressions and Pattern Matching

Matching Names and Surnames

Matching Integers

Matching the Fields of a Record

Improving the Phone Book Application I

Improving the Phone Book Application II

Exercise 1: Composite Data Types

Solution 1: Composite Data Types

Exercise 2: Composite Data Types

Solution 2: Composite Data Types

Recap: Composite Data Types

Reflection and Interfaces

22 Lessons

Deepen your knowledge of implementing reflection and interfaces in Go for dynamic typing and sorting.

Introduction

Reflection

Learning the Internal Structure of a Go Structure

Changing Structure Values Using Reflection

Type Methods

Interfaces

The sort.Interface Interface

The Empty Interface

Type Assertions and Type Switches

Safely Handling Arbitrary Data

The error Data Type

Writing Our Own Interfaces I

Writing Our Own Interfaces II

Working with Two Different CSV File Formats

Limitations of Object-Oriented Programming in Go

Updating the Phone Book Application I

Updating the Phone Book Application II

Exercise 1: Reflection and Interfaces

Solution 1: Reflection and Interfaces

Exercise 2: Reflection and Interfaces

Solution 2: Reflection and Interfaces

Recap: Reflection and Interfaces

Go Packages and Functions

26 Lessons

Follow the process of developing, using, and managing Go packages, functions, and modules.

Introduction

Go Packages

Functions

Naming Return Values in Go Functions

Functions That Accept Other Functions as Parameters

Functions That Return Other Functions

Variadic Functions

The defer Keyword

Developing Our Own Packages

Using GitHub to Store Go Packages

A Package for Working with a Database

Getting to Know Our Database

The Design and Implementation of the Go Package

Testing the Go Package

Modules and Creating Better Packages

Generating Documentation

GitLab Runners and Go

GitHub Actions and Go

Versioning Utilities

Exercise 1: Go Packages and Functions

Solution 1: Go Packages and Functions

Exercise 2: Go Packages and Functions

Solution 2: Go Packages and Functions

Exercise 3: Go Packages and Functions

Solution 3: Go Packages and Functions

Recap: Go Packages and Functions

Telling a UNIX System What to Do

36 Lessons

Master UNIX system programming with Go, covering file I/O, JSON/XML handling, signals, and Cobra utilities.

Introduction

UNIX Operating System

Handling UNIX Signals

File I/O

Buffered and Unbuffered File I/O

Reading Text Files

Reading a Text File Word by Word

Reading a Text File Character by Character

Reading from /dev/random

Reading a Specific Amount of Data from a File

Writing to a File

Working with JSON

Structures and JSON

Reading and Writing JSON Data as Streams

Pretty Printing JSON Records

Working with XML

Converting JSON to XML and Vice Versa

Working with YAML

The viper Package: Using Command-Line Flags

The viper Package: Reading JSON Configuration Files

The cobra Package I

The cobra Package II

Finding Cycles in a UNIX File System

Embedding Files

ReadDir and DirEntry

The io/fs Package

Updating the Phone Book Application

Exercise 1: Telling a UNIX System What to Do

Solution 1: Telling a UNIX System What to Do

Exercise 2: Telling a UNIX System What to Do

Solution 2: Telling a UNIX System What to Do

Exercise 3: Telling a UNIX System What to Do

Solution 3: Telling a UNIX System What to Do

Exercise 4: Telling a UNIX System What to Do

Solution 4: Telling a UNIX System What to Do

Recap: Telling a UNIX System What to Do

Go Concurrency

40 Lessons

Sharpen your skills in Go concurrency with goroutines, channels, mutexes, and context management.

Introduction

Processes, Threads, and Goroutines

The Go Scheduler

The GOMAXPROCS Environment Variable

Goroutines

Creating Multiple Goroutines

Waiting for Our Goroutines to Finish

What If the Number of Add() and Done() Calls Differ?

Creating Multiple Files with Goroutines

Channels

Receiving from a Closed Channel

Channels as Function Parameters

Race Conditions

The select Keyword

Timing Out a Goroutine

Shared Memory and Shared Variables

What Happens If We Forget to Unlock a Mutex?

The sync.RWMutex Type

The atomic Package

Sharing Memory Using Goroutines

Closured Variables and the go Statement

The context Package

Using context as a Key/Value Store

The semaphore Package

Exercise 1: Go Concurrency

Solution 1: Go Concurrency

Exercise 2: Go Concurrency

Solution 2: Go Concurrency

Exercise 3: Go Concurrency

Solution 3: Go Concurrency

Exercise 4: Go Concurrency

Solution 4: Go Concurrency

Exercise 5: Go Concurrency

Solution 5: Go Concurrency

Recap: Go Concurrency

Building Web Services

26 Lessons

Get started with creating Go-based web services, HTTP handling, Docker images, and Prometheus metrics.

Introduction

The net/http Package

Creating a Web Server

Updating the Phone Book Application

Using Prometheus for Performance Evaluation

Exposing Metrics

Creating a Docker Image for a Go Server

Exposing the Desired Metrics

Using Prometheus and Grafana to Visualize the Metrics

Developing Web Clients

Using http.NewRequest() to Improve the Client

Creating a Client for the Phone Book Service

Creating File Servers

Downloading the Contents of the Phone Book Application

Timing Out HTTP Connections

Setting the Timeout Period on the Client Side

Setting the Timeout Period on the Server Side

Exercise 1: Building Web Services

Solution 1: Building Web Services

Exercise 2: Building Web Services

Solution 2: Building Web Services

Exercise 3: Building Web Services

Solution 3: Building Web Services

Exercise 4: Building Web Services

Solution 4: Building Web Services

Recap: Building Web Services

10.

Working with TCP/IP and WebSocket

26 Lessons

Work your way through TCP/IP, UDP, UNIX Domain Sockets, and WebSocket server/client creation.

Introduction

TCP/IP

Developing a TCP Client

Developing a TCP Client That Uses net.DialTCP()

Developing a TCP Server

Developing a TCP Server That Uses net.ListenTCP()

Developing a UDP Client

Developing a UDP Server

Developing Concurrent TCP Servers

Working with UNIX Domain Sockets

A UNIX Domain Socket Client

Creating a WebSocket Server

The Implementation of the Server

Using JavaScript

Creating a WebSocket Client

Exercise 1: Working with TCP/IP and WebSocket

Solution 1: Working with TCP/IP and WebSocket

Exercise 2: Working with TCP/IP and WebSocket

Solution 2: Working with TCP/IP and WebSocket

Exercise 3: Working with TCP/IP and WebSocket

Solution 3: Working with TCP/IP and WebSocket

Exercise 4: Working with TCP/IP and WebSocket

Solution 4: Working with TCP/IP and WebSocket

Exercise 5: Working with TCP/IP and WebSocket

Solution 5: Working with TCP/IP and WebSocket

Recap: Working with TCP/IP and WebSocket

11.

Working with REST APIs

22 Lessons

Build a foundation in developing and testing RESTful APIs using Go, including client-server interactions and database integrations.

Introduction

An Introduction to REST

Developing RESTful Servers and Clients

A RESTful Server

A RESTful Client

Creating a Functional RESTful Server

Working with the Database

Testing the restdb Package

Implementing the RESTful Server

Testing the RESTful Server

Creating a RESTful Client

Uploading and Downloading Binary Files

Using Swagger for REST API Documentation

Exercise 1: Working with REST APIs

Solution 1: Working with REST APIs

Exercise 2: Working with REST APIs

Solution 2: Working with REST APIs

Exercise 3: Working with REST APIs

Solution 3: Working with REST APIs

Exercise 4: Working with REST APIs

Solution 4: Working with REST APIs

Recap: Working with REST APIs

12.

Code Testing and Profiling

29 Lessons

Optimize Go code performance and correctness through testing, profiling, benchmarking, and tracing techniques.

The go tool trace Utility

Tracing a Web Server from a Client

Visiting All Routes of a Web Server

Testing Go Code

The TempDir Function

The testing/quick Package

Testing Code Coverage

Finding Unreachable Go Code

Testing an HTTP Server with a Database Backend

Fuzzing

Cross-Compilation

Using go:generate

Creating Example Functions

Exercise 1: Code Testing and Profiling

Solution 1: Code Testing and Profiling

Exercise 2: Code Testing and Profiling

Solution 2: Code Testing and Profiling

Exercise 3: Code Testing and Profiling

Solution 3: Code Testing and Profiling

Exercise 4: Code Testing and Profiling

Solution 4: Code Testing and Profiling

Exercise 5: Code Testing and Profiling

Solution 5: Code Testing and Profiling

Recap: Code Testing and Profiling

13.

Working with gRPC

16 Lessons

Focus on implementing gRPC services in Go, including server, client, and protocol buffer definitions.

Introduction

Introduction to gRPC

Defining an Interface Definition Language File

Developing a gRPC Server

Developing a gRPC Client

Exercise 1: Working with gRPC

Solution 1: Working with gRPC

Exercise 2: Working with gRPC

Solution 2: Working with gRPC

Exercise 3: Working with gRPC

Solution 3: Working with gRPC

Exercise 4: Working with gRPC

Solution 4: Working with gRPC

Exercise 5: Working with gRPC

Solution 5: Working with gRPC

Recap: Working with gRPC

14.

Go Generics

17 Lessons

Build on understanding Go generics, their applications, constraints, interfaces, and practical exercises.

Introduction

Our First Generic Function

Constraints

Creating Constraints

Defining New Data Types with Generics

Using Generics in Go Structures

Interfaces vs. Generics

Reflection vs. Generics

Exercise 1: Go Generics

Solution 1: Go Generics

Exercise 2: Go Generics

Solution 2: Go Generics

Exercise 3: Go Generics

Solution 3: Go Generics

Exercise 4: Go Generics

Solution 4: Go Generics

Recap: Go Generics

15.

Conclusion

1 Lessons

Step through Go's features, concurrency, networking, and practical applications for real-world use.

Wrap Up

16.

Appendix A—Go Garbage Collector

5 Lessons

Get insights into Go's garbage collector, memory allocation, and performance optimization techniques.

Introduction

Garbage Collection

The Tricolor Algorithm

More About the Operation of the Go Garbage Collector

Maps, Slices, and the Go Garbage Collector

Course Author

Packt

Trusted by 2.6 million developers working at companies

"These are high-quality courses. Trust me. I own around 10 and the price is worth it for the content quality. EducativeInc came at the right time in my career. I'm understanding topics better than with any book or online video tutorial I've done. Truly made for developers. Thanks"

Anthony Walker

@_webarchitect_

"Just finished my first full #ML course: Machine learning for Software Engineers from Educative, Inc. ... Highly recommend!"

Evan Dunbar

ML Engineer

"You guys are the gold standard of crash-courses... Narrow enough that it doesn't need years of study or a full blown book to get the gist, but broad enough that an afternoon of Googling doesn't cut it."

Carlos Matias La Borde

Software Developer

"I spend my days and nights on Educative. It is indispensable. It is such a unique and reader-friendly site"

Souvik Kundu

Front-end Developer

"Your courses are simply awesome, the depth they go into and the breadth of coverage is so good that I don't have to refer to 10 different websites looking for interview topics and content."

Vinay Krishnaiah

Software Developer

"I've tried probably 5-7 different sites and Educative is easily the best. It perfectly blends explanation with interactivity"

Eric Downs

Musician/Entrepeneur

Hands-on Learning Powered by AI

See how Educative uses AI to make your learning more immersive than ever before.

Instant Code Feedback

Evaluate and debug your code with the click of a button. Get real-time feedback on test cases, including time and space complexity of your solutions.

AI-Powered Mock Interviews

Put your skills to the test in a simulated interview setting. Receive personalized feedback based on your performance. Available in Premium & Premium Plus plans.

Adaptive Learning

At various checkpoints throughout Educative courses, you will be prompted to take a quick assessment. Receive a condensed curriculum tailored to your strengths and skill gaps.

Explain with AI

Select any text within any Educative course, and get an instant explanation — without ever leaving your browser.

AI Code Mentor

AI Code Mentor helps you quickly identify errors in your code, learn from your mistakes, and nudge you in the right direction — just like a 1:1 tutor!

Recommended before starting this course

Course

An Introduction to Programming in Go

Explore Go programming, understanding its concurrency advantages over traditional languages. Gain insights into why Go is crucial as Moore’s Law fades, suitable for beginners.

beginner

6 hours

Course

Concurrency in Go

Gain insights into Go's concurrency, delve into efficient programming techniques, learn advanced concepts, and discover how to enhance performance and robustness in your applications.

beginner

15 hours

Course

Learning Test-Driven Development with Go

Gain insights into TDD with Go. Learn Go fundamentals, write test cases, explore TDD katas, and build a TODO app to master reliable application development practices.

beginner

10 hours

Course

An Introduction to Programming in Go

Learning Test-Driven Development with Go

beginner

10 hour

Related Courses and Skill Paths

Course

Mastering Concurrency in Go

Gain insights into implementing concurrency in Go, explore common patterns, and learn to write efficient, practical applications leveraging Go's outstanding support for concurrency.

intermediate

6 hours

Course

API Development in Go Using MongoDB

Gain insights into building robust APIs with Go and MongoDB. Learn about CRUD operations, authentication, integration, and enhance your skills with practical examples and hands-on exercises.

intermediate

15 hours

Course

Grokking the Coding Interview Patterns in Go

Grokking the Coding Interview Patterns in Go helps you prep faster with strategies developed by FAANG engineers. Learn essential patterns to confidently tackle interview questions from top companies.

intermediate

85 hours

Course

Mastering Concurrency in Go

intermediate

6 hour

Course

API Development in Go Using MongoDB

intermediate

15 hour

Course

Grokking the Coding Interview Patterns in Go