The Go Programming Language
In this course we will learn about the Go programming language from Google. We'll cover most of the language and look at interesting topics like concurrency.
Authored by:
John Sonmez
Duration: 4h 35m
Level: Intermediate
Released: 2/15/2013
Features:
Duration: 4h 35m
Level: Intermediate
Released: 2/15/2013
Features:
Course Rating:
You are currently not signed in. Please sign in to access subscriber-only content.
Currently using: {{getCurrentPlayerName()}} [Change]
| expand all | collapse all | Progress | Duration | |
|---|---|---|---|
Go Overview |
|
00:26:02 | |
|
Introduction
|
|
01:03 | |
|
Course overview
|
|
02:27 | |
|
What is Go?
|
|
02:18 | |
|
More about Go
|
|
04:19 | |
|
Go's origins
|
|
03:19 | |
|
What makes Go different?
|
|
05:52 | |
|
C, C++ and Go
|
|
01:49 | |
|
Looking at some Go code
|
|
03:50 | |
|
Summary
|
|
01:05 | |
Go Development |
|
00:31:32 | |
|
Introduction
|
|
00:34 | |
|
Development Choices
|
|
03:55 | |
|
Getting Go
|
|
00:40 | |
|
Installing Go
|
|
02:04 | |
|
Packages
|
|
02:10 | |
|
Imports
|
|
01:31 | |
|
Go Tour
|
|
00:59 | |
|
Creating a Workspace
|
|
03:00 | |
|
Hello World
|
|
03:29 | |
|
Installing a Go Program
|
|
02:27 | |
|
The Go IDE
|
|
05:26 | |
|
Hello World in the IDE
|
|
04:07 | |
|
Summary
|
|
01:10 | |
Variables, Types and Pointers |
|
00:34:16 | |
|
Introduction
|
|
00:41 | |
|
Basic Types
|
|
03:13 | |
|
Other Types
|
|
02:29 | |
|
Basic Declaration
|
|
01:26 | |
|
Multi-Declaration and Initialization
|
|
03:14 | |
|
Pointer Basics
|
|
03:12 | |
|
Passing Things
|
|
02:34 | |
|
Basic Pointer Example
|
|
02:48 | |
|
Pointer Assignment
|
|
01:25 | |
|
No Classes in Go
|
|
01:46 | |
|
Basic User Types
|
|
05:37 | |
|
Constants
|
|
01:01 | |
|
Constant Examples
|
|
03:35 | |
|
Summary
|
|
01:15 | |
Functions |
|
00:29:33 | |
|
Introduction
|
|
00:27 | |
|
What is a Function?
|
|
00:54 | |
|
Go Functions
|
|
02:07 | |
|
Basic Function Declaration
|
|
04:25 | |
|
Adding a Return
|
|
02:09 | |
|
Multiple Returns
|
|
03:05 | |
|
Named Returns
|
|
02:00 | |
|
Variadic Functions
|
|
00:26 | |
|
Variadic Function Example
|
|
02:42 | |
|
Function Types
|
|
00:36 | |
|
Passing a Function
|
|
02:50 | |
|
Declaring a Function Type
|
|
01:27 | |
|
Closures
|
|
04:38 | |
|
Closure Example
|
|
00:18 | |
|
Summary
|
|
01:29 | |
Branching |
|
00:24:03 | |
|
Introduction
|
|
00:50 | |
|
If Statements
|
|
01:27 | |
|
Basic If
|
|
05:32 | |
|
Embedded Statements
|
|
02:15 | |
|
Else
|
|
00:48 | |
|
Switch Overview
|
|
00:56 | |
|
Switch Differences
|
|
02:43 | |
|
Basic Switch
|
|
02:25 | |
|
Switch Tricks
|
|
01:15 | |
|
Switch on Nothing
|
|
02:22 | |
|
Switch on Type
|
|
02:25 | |
|
Summary
|
|
01:05 | |
Loops |
|
00:18:12 | |
|
Introduction
|
|
00:31 | |
|
There can only be one
|
|
01:04 | |
|
The for statement
|
|
01:54 | |
|
Basic for
|
|
01:43 | |
|
While loop
|
|
01:18 | |
|
Infinite loop
|
|
01:24 | |
|
Break
|
|
01:22 | |
|
Continue
|
|
01:22 | |
|
Ranges
|
|
02:20 | |
|
Ranges Example
|
|
04:14 | |
|
Summary
|
|
01:00 | |
Maps |
|
00:28:00 | |
|
Introduction
|
|
01:01 | |
|
What is a Map?
|
|
01:29 | |
|
Maps in Go
|
|
01:20 | |
|
Creating a Map
|
|
02:51 | |
|
Inserting into a Map
|
|
02:33 | |
|
Map operations
|
|
01:19 | |
|
Shorthand Maps
|
|
02:26 | |
|
Updating a Map
|
|
01:20 | |
|
Delete from a Map
|
|
02:40 | |
|
Installing the latest
|
|
02:05 | |
|
Installing the new plugin
|
|
02:12 | |
|
Converting to the new IDE
|
|
02:28 | |
|
Checking for existence
|
|
02:38 | |
|
Summary
|
|
01:38 | |
Slices |
|
00:19:46 | |
|
Introduction
|
|
00:54 | |
|
What is an Array?
|
|
03:02 | |
|
What is a Slice?
|
|
02:19 | |
|
Properties of a Slice
|
|
01:29 | |
|
A basic Slice
|
|
02:44 | |
|
Short Slice syntax
|
|
01:16 | |
|
Slicing Slices
|
|
02:18 | |
|
Appending
|
|
02:22 | |
|
Deleting from a Slice
|
|
01:38 | |
|
Summary
|
|
01:44 | |
Methods and Interface |
|
00:23:59 | |
|
Introduction
|
|
00:39 | |
|
Go Methods
|
|
01:48 | |
|
Pointer Methods
|
|
01:49 | |
|
Creating a Method
|
|
04:18 | |
|
Creating a Pointer Receiver
|
|
02:46 | |
|
What is an Interface?
|
|
02:17 | |
|
Creating an Interface
|
|
03:13 | |
|
Empty Interface
|
|
00:48 | |
|
Empty Interface Code
|
|
00:46 | |
|
Implementing Writer
|
|
02:28 | |
|
Using Writer
|
|
02:00 | |
|
Summary
|
|
01:07 | |
Concurrency |
|
00:40:20 | |
|
Introduction
|
|
00:53 | |
|
The Concurrency Problem
|
|
02:14 | |
|
The Code Problem
|
|
01:38 | |
|
Real World Solution
|
|
01:47 | |
|
How Go Solves It
|
|
01:26 | |
|
Goroutines
|
|
00:49 | |
|
Basic Goroutines
|
|
03:14 | |
|
Channels
|
|
01:23 | |
|
Basic Channels
|
|
04:57 | |
|
Buffered Channel
|
|
06:25 | |
|
Channels with Range
|
|
06:07 | |
|
Select Statement
|
|
01:35 | |
|
Using Select
|
|
06:15 | |
|
Summary
|
|
01:37 |
Go Overview