Ultimate Go: Advanced Concepts

Ultimate Go: Advanced Concepts

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 74 Lessons (15h 05m) | 8.34 GB

Go is lightweight, simple, and perfect for modern cloud-native and microservices development.

Ultimate Go: Advanced Concepts Video Course provides an intensive, comprehensive, and idiomatic view of the Go programming language. This course focuses on both the specification and implementation of the language, including topics ranging from language syntax, design, and guidelines to concurrency, testing, and profiling. This class is perfect for anyone who wants a jump-start in learning Go or wants a more thorough understanding of the language and its internals.

In this video training, William Kennedy starts by providing a deep and intensive dive into Go’s language syntax, idioms, implementation, and specification. Then Bill guides you through the essential things you need to know about designing software in Go. With that strong foundation, Bill then teaches the language mechanics behind Go’s concurrency primitives and covers all the things you need to know to design concurrent software. Finally, Bill covers the tooling Go provides for testing, tracing, and profiling your programs.

Learn How To

  • Write better, more idiomatic, and performant code
  • Focus on micro-level engineering decisions
  • Use your new understanding of the internals to leverage the core tradeoffs on readability, simplicity and performance.
  • Utilize data semantics, guidelines, mechanical sympathy, data-oriented design, and package-oriented design
  • Structure your Go projects for the long term.
  • Manage packages, modules, and dependencies
Table of Contents

Lesson 1 Strings and Formatted Output
1 Prepare Your Mind
2 Productivity versus Performance
3 Correctness versus Performance
4 Code Reviews
5 If Performance Matters

Lesson 2 Memory and Data Semantics
6 Variables
7 Struct Types
8 Pointers Pass by Values
9 Pointers Sharing Data
10 Pointers Escape Analysis
11 Pointers Stack Growth
12 Pointers GC
13 Constants

Lesson 3 Data Structures
14 Arrays Mechanical Sympathy
15 Arrays Semantics
16 Arrays Range Mechanics
17 Slices Declare, Length, and Reference Types
18 Slices Appending Slices
19 Slices Taking Slices of Slices
20 Slices Strings and References
21 Slices Strings and Slices
22 Slices Range Mechanics
23 Maps

Lesson 4 Decoupling
24 Methods Value and Pointer Semantics
25 Methods FunctionMethod Variables
26 Interfaces Polymorphism
27 Interfaces Method Sets and Address of Value
28 Interfaces Storage by Value
29 Interfaces Type Assertion
30 Embedding
31 Exporting

Lesson 5 Composition
32 Grouping Types
33 Decoupling
34 Conversion and Assertions Part 1
35 Conversion and Assertions Part 2
36 Interface Pollution
37 Mocking

Lesson 6 Error Handling
38 Default Error Values
39 Error Variables
40 Type as Context
41 Behavior as Context
42 Find the Bug
43 Wrapping Errors

Lesson 7 Packaging
44 Language Mechanics & Design Guidelines
45 Package Oriented Design

Lesson 8 Go Routines
46 OS Scheduler Mechanics
47 Go Scheduler Mechanics
48 Creating Go Routines

Lesson 9 Data Races
49 Managing Data Races

Lesson 10 Channels
50 Signaling Semantics
51 Basic Patterns
52 Fan Out
53 Wait for Task
54 Pooling
55 Fan Out Semaphore
56 Fan Out Bounded
57 Drop Pattern
58 Cancellation Pattern

Lesson 11 Concurrency Patterns
59 Failure Detection

Lesson 12 Testing
60 Basic Unit Testing
61 Table Unit Testing
62 Mocking Web Server Response
63 Testing Internal Endpoints
64 Sub Tests
65 Code Coverage

Lesson 13 Benchmarks
66 Basic Benchmarking
67 Validate Benchmarking
68 CPU-Bound Benchmarking
69 IO-Bound Benchmarking

Lesson 14 Profiling and Tracing
70 Profiling Guidelines
71 Stack Traces
72 Micro Level Optimization
73 Macro Level Optimization
74 Execution Tracing