Academind – Getting Started With Golang 2021-7 – Full Version

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

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

What is Go and how does it work
Speaker structure and rules
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
Peculiarities of this language such as multiple return values
How to organize your code into packages and modules
Work with third-party modules
Run and create Go programs
It’s about controlling the flow of code using loops and conditional sentences
Complex data structures like structs
Community data like arrays, slices, and maps
Complete and understandable understanding of “pointers”
Learn advanced functions such as “Recursion”
Detailed description of the interfaces
Use and integration of interfaces and Struct
All about synchronization, goroutines and channels

Course specifications

Publisher: Academy
Instructors: Maximilian Schwarzmuller
French language
Education Level: Basic to Advanced
Number of courses: 121
Duration: 11 hours and 30 minutes

Topics in the Getting Started with Golang course:

To start
Welcome to class (1:00)
What is GB? (6:12)
Why would you use Go? (3:52)
Installing Go (3:55)
Code Editor Setup (VS Code) (2:40)
Finalizing editor setup and first 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, and Types
Module overview (1:26)
Basic syntax and language features (9:08)
Getting Started with Values and Value Types (5:25)
Explore variables (9:34)
Int type and math operations (8:20)
Practice time: problem (5:38)
Practice time: solution (10:24)
Working with Floats and Type Conversions (7:47)
float64 vs. float32 (3:30)
Variables & “Null Values”
A brief overview of “bool”, “rune”, and “byte” types (7:10)
String operations and type conflicts (6:26)
Working with multiline strings
Formatting strings (11:05)
Practice Time: Problem (2:41)
Practice Time: Solution (7:36)
Go plans and modules: the theory (5:33)
Create and use a first module (4:59)
Working with Packages and Exports + Imports (9:01)
Using Constant Values (Constants) (3:54)
Module Summary (2:52)
Module resources

Go Basics – Time To Practice (Creating a BMI Calculator App) Module overview (1:49)
Creating our Go module (4:23)
Print out (3:40)
Fetching user input (8:19)
Cleaning and analyzing user input (10:15)
Calculating BMI and outputting formatted strings (3:40)
Using Constant Values (4:20)
Divide our code into files and packages (7:38)
American / English units

Working with functions
Module overview (0:49)
What is a “function”? (3:49)
Create a function and work with parameters + return values (10:10)
Practice functions (3:43)
Go special function: multiple return values (7:56)
Using Named Return Values (3:39)
Module summary (1:38)

Functions – Time To Practice (Enhancing The BMI Project)

Module overview (2:52)
Creating a first function (3:44)
Outsourcing User Input Logic (5:21)
Finish refactoring the “main” function (5:22)
Avoiding Code Duplication (6:24)
Module Summary (1:11)

Understanding Pointers
Module overview (0:46)
What are pointers and why do we have them? (8:07)
Creating a first pointer (5:06)
Working with pointers (5:35)
Advantages of pointers (and disadvantages) (8:47)

“Structure” data with Structs
Module overview (0:54)
What and why + Defining a first structure (9:25)
Creating Structure Instances (6:21)
Creating structures with “creation functions” (3:39)
Structures and pointers (4:31)
Access Structure Values (8:41)
Adding Methods to Structures (7:19)
Module summary (4:17)

Structs – Time To Practice (storing data in files)
Module overview (3:06)
Define structure (3:29)
Creating Structure Instances (9:44)
Adding a method (5:02)
Reading user input (14:06)
Writing to Files (7:53)

Data collection: tables, slices and maps

Module overview (1:08)
Overview of Arrays for Storing Lists of Data (8:02)
Working with tables (6:18)
Selecting parts of arrays with slices (3:26)
Other ways to use slices (2:23)
Slices – Deep Dive (9:43)
Creating Dynamic Lists with Slices (9:16)
Practice Time – Problem (4:17)
Practice Time – Solution (20:10)
Unpacking list values (3:29)
Introducing Maps (6:48)
Mutating Cards (3:41)
Maps vs Structures (4:00)

Working with Control Structures
Module overview (1:14)
Work on project setup (5:34)
Introduction to “if” statements (3:46)
Learn about “if” statements and Boolean (Boolean) values (4:40)
“Else” & “Else if” (5:08)
Combination Terms (4:28)
Using “switch” statements
Handling Expected Errors (8:10)
Returning Errors in Functions (3:33)
Practicing what we learned (13:50)
Onward to “loops” (and why do we need them?) (5:44)
Introducing a Basic “For” Loop (5:11)
A More Useful Loop (2:55)
Practice basic “for” loops (4:22)
Go’s “while” Loop (9:43)
Prepare another scenario (5:29)
Loop through collections (arrays, slices, maps) (5:22)
“continue” and “discontinue” (2:33)
Module Summary (2:47)

The main project: creating the game “Monster Slayer”
Module overview (1:46)
Application Planning (5:20)
Project initialization (2:12)
Added base game steps and logic (5:24)
Outputting text and adding a first package (4:05)
Keep track of active lap (4:59)
Showing available player actions (3:38)
Getting Started with Fetching User Input (6:54)
Validating and Using User Input (11:05)
Generating (real) random numbers (7:17)
Add logic for different actions (7:02)
Use constants (5:45)
Search for a winner (11:12)
Added “Endgame” logic (3:50)
Round data output (with a structure) (18:05)
Managing multiple rounds (with a slice) (5:45)
Write to log file (10:11)
Module summary (1:12)

Third-party modules and creation of Go applications

Module overview (1:17)
Using third-party modules (10:46)
Building and distribution modules
Creating Go Projects (standalone executables) (3:50)
A Gotcha: Executables and File Paths (7:38)

Dive deeper into values, variables and constants
Module overview (1:30)
Variables, scope and variable shading (7:35)
“doing” values (10:26)
The “new” function (7:01)
new vs do (1:21)
Working with Custom Types (10:35)
Learn more about custom types
Learn about constants (7:55)
Module summary (3:18)

Dive deeper into functions
Module overview (0:59)
Using Functions as Function Values and Types (15:10)
Returning functions in Functions (6:21)
Overview of Anonymous Functions (6:34)
Working with Closures (6:42)
Use recursion (11:20)
Introduction to Variadic Functions (6:47)
Splitting Slices into Parameter Lists (3:05)
Defer function execution with “defer” (9:04)
Panic! (4:10)
Module summary (2:42)

Working with Interfaces
Module overview (0:55)
What is the problem? (6:31)
Interfaces as a solution (i.e. what are interfaces?) (6:17)
Sample time: Built-in interfaces we’ve used before (4:54)
Interfaces: Rules and Conventions (5:06)
Empty Interfaces (4:36)
Flexible Code with Empty Interfaces and Type Switches (11:03)
Module summary (1:30)

Integration of interfaces and structures
Module overview (0:44)
Integration Interfaces (8:15)
Integration of structures (5:57)

Concurrency, goroutines and channels
Module overview (0:53)
What is concurrency? (1:43)
Introducing Goroutines (7:45)
Working with Channels (8:59)
Play from a channel multiple times (1:59)
Transmitting values through channels (8:25)
Loop on channel values (5:26)
Using Buffered Channels (7:04)
Using the “select” statement (4:09)
Module Summary (2:43)

Course prerequisites:

NO prior knowledge of Go is required.

General knowledge of programming (any language) is helpful but also NOT necessary.

Pictures

First steps with Golang

Sample First Steps with Golang movie:

Installation guide

After ripping, watch with your favorite player.

Subtitle: None

Quality: 1080p

Course changes:

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