Academind - Getting Started With Golang 2021

Academind – Getting Started With Golang 2021


Getting Started With Golang is a course that teaches all the key principles of using the Go programming language, which is one of the most sought-after and popular languages.

What you will learn in the Getting Started With Golang course:

  • What Go is and how it works
  • Structure and rules of the speaker
  • Key principles of working with values ​​and variables
  • Everything about the types of Go values, how to change them, and how to use them
  • How to write functions in the Go language
  • Special features of this language such as multiple return values
  • How to arrange your code in packages and modules
  • Work with third-party modules
  • Run and build Go programs
  • It’s all about controlling the flow of code using loops and conditional sentences
  • Complex data structures like structs
  • Data community such as arrays, slices, and maps
  • Full and understandable understanding of “Pointers”
  • Learn advanced functions such as “Recursion”
  • A detailed description of the interfaces
  • Utilization and integration of interfaces and Structs
  • All about synchronization, Goroutines, and channels

Course specifications

Publisher: Academind
Instructors: Maximilian Schwarzmüller
Language: English
Education Level: Basic to Advanced
Number of Courses: 121
Duration: 11 hours and 30 minutes


See Also:

Download Microsoft Power BI Report Server May 2021

Boris FX (Genarts) Sapphire Suite 2021.5 Windows / 2019.0 macOS Free

Smith Micro Moho Pro 13.5.20210422 Multilingual

Adobe After Effects 2021 v18.2.1.8 Windows / macOS

Trimble Tekla Structures 2021 SP2 + Environments

Course Topics Getting Started With Golang:

Getting Started
Welcome To The Course (1:00)
What Is Go? (6:12)
Why Would You Use Go? (3:52)
Installing Go (3:55)
Code Editor Setup (VS Code) (2:40)
Finishing Editor Config & First Go Code (6:53)
Basic Programming Knowledge Helps! (1:55)
About This Course (2:21)
How To Get The Most Out Of This Course (3:50)
Using Code Snapshot Attachments

Go Basics: Values, Variables & Types
Module Introduction (1:26)
Base Syntax & Language Features (9:08)
Getting Started With Values & Value Types (5:25)
Exploring Variables (9:34)
The “int” Type & Math Operations (8:20)
Time To Practice: Problem (5:38)
Time To Practice: Solution (10:24)
Working With Floats & Type Conversions (7:47)
float64 vs float32 (3:30)
Variables & “Null Values”
A Brief Look At “bool”, “rune” and “byte” Types (7:10)
String Operations & Type Clashes (6:26)
Working with Multiline Strings
Formatting Strings (11:05)
Time To Practice: Problem (2:41)
Time To Practice: Solution (7:36)
Go Packages & Modules: The Theory (5:33)
Creating & Using A First Module (4:59)
Working With Packages & Exports + Imports (9:01)
Using Constant Values (Constants) (3:54)
Module Summary (2:52)
Module Resources

Go Basics – Time To Practice (Building a BMI Calculator App)Module Introduction (1:49)
Creating Our Go Module (4:23)
Printing Output (3:40)
Fetching User Input (8:19)
Cleaning & Parsing User Input (10:15)
BMI Calculation & Outputting Formatted Strings (3:40)
Using Constant Values (4:20)
Splitting Our Code Into Files & Packages (7:38)
US / English Units

Working with Functions
Module Introduction (0:49)
What Is A “Function”? (3:49)
Creating A Function & Working With Parameters + Return Values (10:10)
Practicing Functions (3:43)
Go Special Feature: Multiple Return Values (7:56)
Using Named Return Values (3:39)
Module Summary (1:38)

Functions – Time To Practice (Enhancing The BMI Project)

Module Introduction (2:52)
Creating a First Function (3:44)
Outsourcing The User Input Logic (5:21)
Finishing the “main” Function Refactoring (5:22)
Avoiding Code Duplication (6:24)
Module Summary (1:11)

Understanding Pointers
Module Introduction (0:46)
What Are Pointers & Why Do We Have Them? (8:07)
Creating a First Pointer (5:06)
Working With Pointers (5:35)
Advantages Of Pointers (& Disadvantages) (8:47)

“Struct” uring Data with Structs
Module Introduction (0:54)
What & Why + Defining a First Struct (9:25)
Creating Struct Instances (6:21)
Creating Structs With “Creation Functions” (3:39)
Structs & Pointers (4:31)
Accessing Struct Values (8:41)
Adding Methods To Structs (7:19)
Module Summary (4:17)

Structs – Time To Practice (Storing Data In Files)
Module Introduction (3:06)
Defining a Struct (3:29)
Creating Struct Instances (9:44)
Adding a Method (5:02)
Reading User Input (14:06)
Writing To Files (7:53)

Data Collections: Arrays, Slices & Maps

Module Introduction (1:08)
Introducing Arrays For Storing Lists Of Data (8:02)
Working With Arrays (6:18)
Selecting Parts Of Arrays With Slices (3:26)
More Ways Of Using Slices (2:23)
Slices – Deep Dive (9:43)
Creating Dynamic Lists With Slices (9:16)
Time To Practice – Problem (4:17)
Time To Practice – Solution (20:10)
Unpacking List Values (3:29)
Introducing Maps (6:48)
Mutating Maps (3:41)
Maps vs Structs (4:00)

Working With Control Structures
Module Introduction (1:14)
Working on the Project Setup (5:34)
Introducing “if” Statements (3:46)
More about “if” Statements & Boolean Values (Booleans) (4:40)
“else” & “else if” (5:08)
Combining Conditions (4:28)
Using “switch” Statements
Handling Expected Errors (8:10)
Returning Errors In Functions (3:33)
Practicing What We Learned (13:50)
Onwards To “Loops” (and why do we need them?) (5:44)
Introducing a Basic “for” Loop (5:11)
A More Useful Loop (2:55)
Practicing Basic “for” Loops (4:22)
Go’s “while” Loop (9:43)
Preparing Another Scenario (5:29)
Looping Through Collections (Arrays, Slices, Maps) (5:22)
“continue” and “break” (2:33)
Module Summary (2:47)

The Main Project: Building the “Monster Slayer” Game
Module Introduction (1:46)
Planning the App (5:20)
Initializing The Project (2:12)
Adding The Core Game Steps & Logic (5:24)
Outputting Text & Adding a First Package (4:05)
Keeping Track Of The Active Round (4:59)
Displaying Available Player Actions (3:38)
Getting Started With Fetching User Input (6:54)
Validating & Using User Input (11:05)
Generating (True) Random Numbers (7:17)
Adding Logic For Different Actions (7:02)
Utilizing Constants (5:45)
Checking For A Winner (11:12)
Adding the “End Game” Logic (3:50)
Outputting Round Data (with a Struct) (18:05)
Managing Multiple Rounds (with a Slice) (5:45)
Writing To A Log File (10:11)
Module Summary (1:12)

Third-Party Modules & Building Go Apps

Module Introduction (1:17)
Using Third-Party Modules (10:46)
Building & Distributing Modules
Building Go Projects (Standalone Executables) (3:50)
A Gotcha: Executables & File Paths (7:38)

Diving Deeper Into Values, Variables & Constants
Module Introduction (1:30)
Variables, Scope & Variable Shadowing (7:35)
“make” ing Values (10:26)
The “new” Function (7:01)
new vs make (1:21)
Working With Custom Types (10:35)
More On Custom Types
More On Constants (7:55)
Module Summary (3:18)

Diving Deeper Into Functions
Module Introduction (0:59)
Using Functions As Values & Function Types (15:10)
Returning Functions In Functions (6:21)
Introducing Anonymous Functions (6:34)
Working with Closures (6:42)
Using Recursion (11:20)
Introducing Variadic Functions (6:47)
Splitting Slices Into Parameter Lists (3:05)
Deferring Function Execution with “defer” (9:04)
Panic! (4:10)
Module Summary (2:42)

Working with Interfaces
Module Introduction (0:55)
What’s the Problem? (6:31)
Interfaces As a Solution (i.e. What are Interfaces?) (6:17)
Example Time: Built-in Interfaces We Already Used (4:54)
Interfaces: Rules & Conventions (5:06)
Empty Interfaces (4:36)
Flexible Code With Empty Interfaces & Type Switches (11:03)
Module Summary (1:30)

Embedding Interfaces & Structs
Module Introduction (0:44)
Embedding Interfaces (8:15)
Embedding Structs (5:57)

Concurrency, Goroutines & Channels
Module Introduction (0:53)
What Is Concurrency? (1:43)
Introducing Goroutines (7:45)
Working With Channels (8:59)
Reading From A Channel Multiple Times (1:59)
Transmitting Values Via Channels (8:25)
Looping Through Channel Values (5:26)
Using Buffered Channels (7:04)
Using The “select” Statement (4:09)
Module Summary (2:43)

Course prerequisites:

NO prior Go knowledge is required.

General programming knowledge (any language) helps but is also NOT required.

Golang Pictures



Golang Installation guide

After Extract, watch with your favorite Player.

Subtitle: None

Quality: 1080p

Golang download link

Download Section 1 – 1 GB
Download Part 2 – 1 GB
Download Section 3 – 1 GB
Download Section 4 – 673 MB
file password link
Follow On Facebook
Follow On Linkedin
Follow On Reddit