Download at MAXIMUM SPEED and remove 503 Error

Purchase a VIP membership and download using our fastest servers, up to 1Gb/s
If you get 503 error while downloading, Become VIP to download with unlimited connections.


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 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”
  • 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

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 (ie 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.


Getting Started With Golang

Sample movie Getting Started With Golang:

Installation guide

After Extract, watch with your favorite Player.

Subtitle: None

Quality: 1080p

Course changes:

Version 2021/7 has increased by 40 lessons for about 4 hours compared to version 2021/6.

download link

Download Part 1 – 1 GB

Download Part 2 – 1 GB

Download Part 3 – 1 GB

Download Part 4 – 1 GB

Download Part 5 – 788 MB

File password (s):


4.8 GB

Share this page

4 Comments. Leave new

  • Mohamed Sayed
    2021-08-02 6:07 pm
    Google Chrome 92 Google Chrome 92 Windows 10 Windows 10
    About: Old Version

    Can you share ” Module Resources ” please.. it’s so important
    Thanks ♥

  • Google Chrome 91 Google Chrome 91 Windows 10 Windows 10
    About: Old Version

    The last in-depth knowledge chapters of the course seem to be missing.
    Is there any chance to get them included? Many thanks.

    – Diving Deeper Into Values, Variables & Constants
    – Diving Deeper Into Functions
    – Working with Interfaces
    – Embedding Interfaces & Structs
    – Concurrency, Goroutines & Channels


Leave a Reply

Your email address will not be published.

Fill out this field
Fill out this field
Please enter a valid email address.
You need to agree with the terms to proceed