CF

Ultimate Go

16h 8m 46s
English
Paid

Ultimate Go is a 91-lesson 16 hours 8 minutes self-paced course by Ardan Labs. Advanced course Ultimate Go developed for those, who want to concentrate on deep learning of language and to understand things that have sense and semanthic.

Course facts

Lessons
91
Duration
16 hours 8 minutes
Language
English
Instructor
Ardan Labs
Price
Premium

Advanced course Ultimate Go developed for those, who want to concentrate on deep learning of language and to understand things that have sense and semanthic.

Additional

https://github.com/ardanlabs/gotraining 

Who teaches Ultimate Go? Ardan Labs

Ardan Labs thumbnail

Ardan Labs is a US training company founded by William Kennedy, focused almost entirely on Go (Golang) and the systems-engineering disciplines around it. Bill Kennedy is one of the most cited Go educators alive — co-author of Go in Action (Manning), maintainer of the Ardan Labs blog, and the lead instructor on a multi-track Go syllabus that runs from beginner through ultimate-Go advanced engineering.

The CourseFlix listing under this source carries nineteen Ardan Labs courses — covering Go language fundamentals, concurrency, advanced engineering patterns, Kubernetes (Bill teaches Go as the implementation language for cloud infrastructure), and the data-engineering / AI tracks Ardan added in recent years. Material is paid and aimed at engineers serious about Go as a career-defining language rather than as a syntax pickup.

What lessons are included in Ultimate Go?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 91 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Intro: Design Guidelines Intro
All Course Lessons (91)
#Lesson TitleDurationAccess
1
Intro: Design Guidelines Intro Demo
00:59
2
1.1 Prepare Your Mind
17:39
3
1.2 - Productivity vs. Performance
06:24
4
1.3 - Correctness vs. Performance
07:14
5
1.4 - Code Reviews
19:17
6
1.5 - If Performance Matters
03:32
7
Intro: Memory & Data Semantics
01:13
8
2.1 Variables
15:04
9
2.2 Struct Types
22:55
10
2.3.1 - Pointers-Part 1 (Pass by Values)
17:44
11
2.3.2 - Pointers-Part 2 (Sharing Data)
07:51
12
2.3.3 - Pointers-Part 3 ( Escape Analysis)
19:47
13
2.3.4 - Pointers-Part 3 ( Stack Growth)
07:55
14
2.3.5 - Pointers-Part 3 ( Garbage Collection)
23:50
15
2.4 - Constants
11:56
16
Garbage Collection Addendum Part 1
15:01
17
Garbage Collection Addendum Part 2
15:32
18
Garbage Collection Addendum Part 3
15:31
19
Intro - Data Structures
01:00
20
3.1 - Arrays-Part 1 (Mechanical Sympathy)
33:21
21
3.2.1 - Arrays-Part 2 (Semantics)
11:10
22
3.2.2 - Arrays-Part 3 (Range Mechanics)
06:40
23
3.3.1 - Slices-Part 1 (Declare, Length & Reference Types)
10:01
24
3.3.2 - Slices-Part 2 (Appending Slices)
19:41
25
3.3.3-Slices-Part 3 (Taking Slices of Slices)
13:29
26
3.3.4 - Slices-Part 4 (Slices & References)
05:35
27
3.3.5 - Slices-Part 5 (Strings & Slices)
10:24
28
3.3.6 - Slices-Part 6 (Range Mechanics)
04:16
29
3.4 - Maps
11:13
30
Intro - Decoupling
00:58
31
4.1.1 - Methods-Part 1 (Value & Pointer Semantics)
16:37
32
4.1.2 - Methods-Part 2 (Function/Method Variables)
14:44
33
4.2.1 - Interfaces-Part 1 (Polymorphism)
18:20
34
4.2.2 - Interfaces-Part 1 (Method Sets & Address of Value)
13:42
35
4.2.3 - Interfaces-Part 3 (Storage by Value)
04:54
36
4.2.4 - Interfaces-Part 4 (Type Assertion)
05:21
37
4.3 - Embedding
09:51
38
4.4 - Exporting
09:52
39
Intro - Composition
01:08
40
5.1 - Grouping Types
15:22
41
5.2.1 - Decoupling-Part 1
37:03
42
5.3.1 - Conversion & Assertions-Part 1
04:50
43
5.3.2 - Conversion & Assertions-Part 2
10:30
44
5.4 - Interface Pollution
08:52
45
5.5 - Mocking
08:16
46
Intro - Error Handling
01:08
47
6.1 - Default Error Values
10:52
48
6.2 - Error Variables
03:40
49
6.3 - Types as Context
07:00
50
6.4 - Behavior as Context
08:14
51
6.5 - Find the Bug
04:20
52
6.6 - Wrapping Errors
10:17
53
Intro - Packaging
01:23
54
7.1 - Language Mechanics & Design Guidelines
11:15
55
7.2 - Package-Oriented Design
15:50
56
Intro - Goroutines
01:10
57
8.1 - OS Scheduler Mechanics
33:01
58
8.2 - Go Scheduler Mechanics
27:11
59
8.3 - Creating Go Routines
19:37
60
Intro - Data Races
01:10
61
9.1 - Managing Data Races
22:15
62
Intro - Channels
01:12
63
10.1 - Signaling Semantics
11:09
64
10.2 - Basic Patterns
06:21
65
10.3 - Fan Out
05:18
66
10.4 - Wait for Task
02:31
67
10.5 - Pooling
05:14
68
10.6 - Fan Out Semaphore
05:22
69
10.7 - Fan Out Bounded
06:15
70
10.8 - Drop Pattern
05:07
71
10.9 - Cancellation Pattern
07:29
72
Intro - Concurrency Patterns
01:12
73
11.1 - Failure Detection
18:30
74
Intro - Testing
01:13
75
12.1 - Basic Unit Testing
09:26
76
12.2 - Table Unit Testing
04:10
77
12.3 - Mocking Web Server Response
07:22
78
12.4 - Testing Internal Endpoints
09:02
79
12.5 - Sub Tests
05:41
80
12.6 - Code Coverage
03:34
81
Intro - Benchmarking
00:42
82
13.1 - Basic Benchmarking
09:25
83
13.2 - Validate Benchmarking
07:01
84
13.3 - CPU-Bound Benchmarking
07:04
85
13.4 - IO-Bound Benchmarking
06:05
86
Intro - Profiling & Tracing
01:06
87
14.1 Profiling Guidelines
05:43
88
14.2 Stack Traces
08:29
89
14.3 Micro Level Optimization
28:21
90
14.4 Macro Level Optimization
24:48
91
14.5 Execution Tracing
38:57
Unlock unlimited learning

Get instant access to all 90 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Ultimate Go?

More courses by Ardan Labs

Frequently asked questions

What prerequisites are needed for this course?
The course is designed for those with an existing understanding of the Go programming language, as it delves into advanced topics. Students should be familiar with basic programming concepts and have some experience in coding with Go. The lessons focus on complex subjects like memory management, concurrency, and error handling, requiring a foundational knowledge of Go to fully benefit from the course material.
What types of projects or exercises will I work on during the course?
While the course does not focus on a specific project, it includes a variety of exercises aimed at deepening understanding of advanced Go concepts. Topics such as garbage collection, data structures, and concurrency are explored through practical examples and code reviews. These exercises are designed to improve performance and correctness in Go programming by applying theoretical knowledge to coding practices.
Who is the target audience for this course?
The course is intended for software developers and engineers who already have a basic understanding of Go and wish to advance their skills. It is particularly useful for those looking to optimize their code for performance and correctness, and for professionals aiming to deepen their knowledge of Go's memory and concurrency models.
How does the scope of this course compare to other Go courses?
This course focuses on the deeper semantic and performance aspects of Go programming, unlike introductory courses that cover basic syntax and programming constructs. With lessons on memory management, advanced data structures, and concurrency, it offers comprehensive coverage of topics that are essential for expert-level proficiency in Go, setting it apart from more general programming courses.
What specific tools or platforms are covered in this course?
The course covers Go-specific tools and concepts, such as the Go Scheduler, Garbage Collection, and Go's approach to memory management and data semantics. It does not focus on external platforms or third-party tools, but rather emphasizes mastering the built-in capabilities of the Go programming language itself.
What topics are not covered in this course?
The course does not cover introductory programming principles or languages other than Go. It also does not focus on building complete applications or frameworks but instead concentrates on enhancing understanding of Go's internal mechanics and improving code performance and correctness through detailed exploration of advanced topics.
What is the time commitment required to complete the course?
The course consists of 91 lessons with a total runtime of approximately 16 hours and 9 minutes. Given its advanced nature, students might need additional time for study and practice beyond the video content to fully absorb and apply the complex concepts covered in the lessons. A commitment of several weeks, depending on prior experience and study pace, would be reasonable to complete the course thoroughly.