Getting Started With Golang – Academind

Description

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 popular and popular languages.

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

What and how the Go language works
The structure and rules of the speaking language
Key principles of working with values and variables
All about Go value types, 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
All about controlling code flow using loops and conditional statements
Complex data structure like structs
Collection of data such as arrays, slices and maps
Complete and comprehensible understanding of “Pointers”
Learning advanced functions such as “Recursion”
Detailed description of interfaces
Use and integration of interfaces and Structs
All about Concurrency, Goroutines and Channels

Course details

Publisher: Academind
Instructors: Maximilian Schwarzmüller
English language
Training level: introductory to advanced
Number of courses: 121
Duration: 11 hours and 30 minutes

Topics of the Getting Started With Golang course:

Getting started
Welcome To The Course (1:00)
What is going? (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)

“Structuring” Data with Structs
Module Introduction (0:54)
What & Why + Defining a First Structure (9:25)
Creating Structure Instances (6:21)
Creating Structures With “Creation Functions” (3:39)
Structures & 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 Structure (3:29)
Creating Structure 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 Structures (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)
“making” 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 & Structures
Module Introduction (0:44)
Embedding Interfaces (8:15)
Embedding Structures (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)

Prerequisites of the Getting Started With Golang course:

NO prior Go knowledge is required.

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

Pictures

Getting Started With Golang sample video:

Installation guide

After Extract, view with your favorite Player.

Subtitle: None

Quality: 1080p

Course changes:

The 2021/7 version has increased the number of 40 lessons for a duration of about 4 hours compared to the 2021/6 version.

Website