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 is the output of the following code?
```Go
package main

import (
	"fmt"
)

func main() {
	var i int
	defer fmt.Print(i)
	i = 1
	fmt.Print(i)
}
```

What is the output of the following code?
<pre><code class="language-Go">package main

import (
	&quot;fmt&quot;
)

func main() {
	var i int
	defer fmt.Print(i)
	i = 1
	fmt.Print(i)
}
</code></pre>

`defer` statements in Go are always executed in First In First Out order once the original function returns. 

`defer` statements in Go are always executed in First In First Out order before the original function is called.

`defer` statements in Go are always executed in Last In First Out order once the original function returns.

`defer` statements in Go are always executed in Last In First Out order before the original function is called.

Which of the following statements is true?

Which of the following statements is true?

Because `defer` functions execute after the function is finished, it can't modify functions' return arguments.

Because <code>defer</code> functions execute after the function is finished, it can’t modify functions’ return arguments.

What is the output of the following code?
```Go
package main

import (
	"fmt"
)

func main() {
	var v int

	for i := 0; i < 3; i++ {
		defer func() {
			v += i
		}()
	}

	fmt.Println(v)
}
```

What is the output of the following code?
<pre><code class="language-Go">package main

import (
	&quot;fmt&quot;
)

func main() {
	var v int

	for i := 0; i &lt; 3; i++ {
		defer func() {
			v += i
		}()
	}

	fmt.Println(v)
}
</code></pre>

Using `recover()` only makes sense in a deferred function that is invoked when the original function is exiting. It can't be used to stop e.g. `for` loop from panicking.

`recover()` can also be used outside of deferred functions.

`recover()` is an equivalent of `try…catch` statements.

Operating system threads typically use 1MB of stack memory each. Starting a 100000 threads then would require around a 100GB of memory. How much memory would 100000 *goroutines* use?

Operating system threads typically use 1MB of stack memory each. Starting a 100000 threads then would require around a 100GB of memory. How much memory would 100000 goroutines use?

If a computer has a CPU with only one core, *goroutines* can still run:

If a computer has a CPU with only one core, goroutines can still run:

If a Go program is configured to run on a single CPU core, you must still protect memory that is accessed concurrently by multiple *goroutines* to avoid race conditions.

Go program will not stop until all the *goroutines* finished executing.

If a *goroutine* panics and no `defer`/`recover` code catches the panic, the whole application will crash.

What is the output of the following code?
```Go
package main

import (
	"fmt"
	"net/http"
)

type httpGetter interface {
	Get(url string) (resp *http.Response, err error)
}

func main() {
	var client *http.Client
	var handler httpGetter
	handler = client
	fmt.Println(client == nil, handler == nil)
}
```

What is the output of the following code?
<pre><code class="language-Go">package main

import (
	&quot;fmt&quot;
	&quot;net/http&quot;
)

type httpGetter interface {
	Get(url string) (resp *http.Response, err error)
}

func main() {
	var client *http.Client
	var handler httpGetter
	handler = client
	fmt.Println(client == nil, handler == nil)
}
</code></pre>

Go program will not panic, it is allowed in Go.

If we call a method on an interface that has a dynamic type set, but its value is `nil`:

If we call a method on an interface that has a dynamic type set, but its value is <code>nil</code>:

To check that the value of interfaces dynamic type is `nil`:

To check that the value of interfaces dynamic type is <code>nil</code>:

Never assign structs that are `nil` to interfaces in your programs and then check with simple equals operator (`== nil`).

Use reflection to get the actual value of the dynamic type.

Add a function `IsNil` to your struct for an easy way to check for `nil`.

Assert concrete type (interfaces dynamic type) and then check if it's `nil`.

What is the best solution to checking if either interface dynamic type is `nil` or dynamic type value is `nil`?

What is the best solution to checking if either interface dynamic type is <code>nil</code> or dynamic type value is <code>nil</code>?

No need to explicitly specify that a `struct` implements an interface.

How does a `struct` implement an interface in Go?

How does a <code>struct</code> implement an interface in Go?

What is the output of the following code?
```Go
package main

import (
	"fmt"
	"io"
)

func main() {
	var w io.Writer
	r := w.(io.Reader)
	fmt.Println(r == nil)
}
```

What is the output of the following code?
<pre><code class="language-Go">package main

import (
	&quot;fmt&quot;
	&quot;io&quot;
)

func main() {
	var w io.Writer
	r := w.(io.Reader)
	fmt.Println(r == nil)
}
</code></pre>

Test your understanding of goroutines and interfaces in Go.

Basics of Go

Data Types

Collection Types

Control Structures

Functions, Goroutines and Interfaces

Inheritance and Equality

Memory and Time

Wrap Up!

Quiz: Goroutines and Interfaces