Gain insights into Go's unique features, delve into advanced memory handling, strings, loops, and goroutines. Discover how to handle multidimensional datasets and protect against variable bugs.

go.tar.gz

unicode_norm

equality_test

equality_bench

memory_first

imports_pkg

exercise

SPA test

Run packages

Go is a popular language known for its simplicity. For developers who lack a deep knowledge of its features, it's a great time to pick up the Go language. The differences between Go and other popular programming languages can lead to hours of Google for the newer software engineer. Mastering these surprising, sometimes delightful, sometimes frustrating features can be the difference between time spent on debugging and time spent on deployment.

In this course, you will go deeper than an introductory book to learn the various features that make Go unique. You’ll learn how to protect against the bugs caused by poorly defined variables (and variable shadowing), how Go treats slicers and arrays similarly, and how to work with multidimensional datasets. You’ll also dive into memory handling, strings, loops, and goroutines.

This course will be most useful if you already have a basic understanding of Go and its syntax. By the end of the course, you’ll move from Go-familiar to Go-expert.

Exploring and Mastering the Full Go Featureset

# What are *goroutines*

For most intents and purposes *goroutines* can be thought of as lightweight threads. They're quick to start, initially use only 2kb of stack memory (which can grow or shrink). They're managed by the Go runtime (rather than the operating system) and context switching between them is cheap. *goroutines* are built for concurrency and
when run on multiple hardware threads they will also run in parallel.

It’s scary how efficient *goroutines* are and when combined with channels they could well be the best feature of Go. They're
everywhere in Go, but an extreme example of a good problem for *goroutines* could be a server managing lots of concurrent websocket
connections. They need to be managed individually, but they're mostly sitting idle (not using much CPU or memory).
Creating a thread for each of them would cause problems once it gets to thousands of connections, while with *goroutines* hundreds of thousands are possible.

# Running *goroutines* don’t stop a program from exiting

Go program exits when the `main` function exits. Any *goroutines* running in the background quietly stop. The following program will exit without printing anything:

Basics of Go

Data Types

Collection Types

Control Structures

Functions, Goroutines and Interfaces

Inheritance and Equality

Memory and Time

Wrap Up!

Goroutines

What are goroutines