Glossary
Auto-generated index of key terms and which lesson covers them.
| Term | Lesson |
|---|---|
| Access, Insert, Delete | 07. Slices & Maps |
| Accessing Fields | 05. Structs & Methods |
| Adding Dependencies with go get | 11. Modules & Packages |
| Analyze and Report | 13. Build a File Scanner |
| Anonymous Functions | 12. Closures & Iterators |
| Anonymous Functions and Closures | 03. Functions |
| append | 07. Slices & Maps |
| Arrays | 07. Slices & Maps |
| Basic Functions | 03. Functions |
| Basic Types | 02. Types & Variables |
| break, continue, and Labels | 04. Control Flow |
| Buffered Channels | 09. Concurrency |
| Channel Direction | 09. Concurrency |
| Channels | 09. Concurrency |
| Checking Errors | 08. Error Handling |
| Closing Channels | 09. Concurrency |
| Closures: Capturing Outer Variables | 12. Closures & Iterators |
| Comma-ok Pattern | 07. Slices & Maps |
| Common Interfaces | 06. Interfaces & Type Assertions |
| Constants | 02. Types & Variables |
| copy | 07. Slices & Maps |
| Creating Errors | 08. Error Handling |
| Creating Instances | 05. Structs & Methods |
| Custom Error Types | 08. Error Handling |
| Deadlock | 09. Concurrency |
| defer | 03. Functions |
| defer + recover Pattern | 08. Error Handling |
| Define the Data | 13. Build a File Scanner |
| Defined Types vs Type Aliases | 02. Types & Variables |
| Defining Structs | 05. Structs & Methods |
| Don't Use panic for Normal Error Handling | 08. Error Handling |
| Empty Interface | 06. Interfaces & Type Assertions |
| error Is an Interface | 08. Error Handling |
| Exercises | 09. Concurrency |
| Exported vs Unexported | 01. Getting Started |
| Exported vs Unexported Fields | 05. Structs & Methods |
| Exported vs Unexported Names | 11. Modules & Packages |
| fmt Package Basics | 01. Getting Started |
| for Loop | 04. Control Flow |
| Format Verbs | 02. Types & Variables |
| Functions as Values | 03. Functions, 12. Closures & Iterators |
| go run vs go build | 01. Getting Started |
| go.mod and go.sum | 11. Modules & Packages |
| Goroutines | 09. Concurrency |
| Hash a File | 13. Build a File Scanner |
| Hello World | 01. Getting Started |
| if/else | 04. Control Flow |
| Implicit Implementation | 06. Interfaces & Type Assertions |
| Importing Packages | 11. Modules & Packages |
| Imports | 01. Getting Started |
| init() Function | 03. Functions |
| Initializing a Module with go mod init | 11. Modules & Packages |
| Installing Go | 01. Getting Started |
| Interface Values | 06. Interfaces & Type Assertions |
| Internal Packages | 11. Modules & Packages |
| Iterating with Closures: The Iterator Pattern | 12. Closures & Iterators |
| Iteration Order Is Random | 07. Slices & Maps |
| len vs cap | 07. Slices & Maps |
| make | 07. Slices & Maps |
| make for Maps | 07. Slices & Maps |
| make vs new | 07. Slices & Maps |
| Maps | 07. Slices & Maps |
| Methods with Value Receivers | 05. Structs & Methods |
| Modules | 01. Getting Started |
| Multi-File Packages | 11. Modules & Packages |
| Multiple Return Values | 03. Functions |
| Named Return Values | 03. Functions |
| new() | 05. Structs & Methods |
| new() vs &Type{} | 10. Pointers & Memory |
| nil Pointers | 10. Pointers & Memory |
| nil Slice vs Empty Slice | 07. Slices & Maps |
| Organizing a Project | 11. Modules & Packages |
| Package Declaration | 11. Modules & Packages |
| Package vs Directory | 11. Modules & Packages |
| Packages | 01. Getting Started |
| panic | 08. Error Handling |
| Pass by Value | 10. Pointers & Memory |
| Pointer Receivers | 05. Structs & Methods |
| Pointer to Struct | 10. Pointers & Memory |
| Pointers | 05. Structs & Methods |
| Practical Closures | 12. Closures & Iterators |
| Practice Alongside (Every Week) | 14. What's Next |
| Process Files Concurrently | 13. Build a File Scanner |
| range | 04. Control Flow |
| Range Over Built-in Types | 12. Closures & Iterators |
| Range Over Channel | 09. Concurrency |
| recover | 08. Error Handling |
| Returning Errors | 08. Error Handling |
| Select | 09. Concurrency |
| Short Declaration | 02. Types & Variables |
| Slices | 07. Slices & Maps |
| Slicing | 07. Slices & Maps |
| Stack vs Heap | 10. Pointers & Memory |
| Standard Library Worth Knowing | 14. What's Next |
| Struct Embedding | 05. Structs & Methods |
| Struct Tags | 05. Structs & Methods |
| switch | 04. Control Flow |
| sync.Mutex | 09. Concurrency |
| sync.WaitGroup | 09. Concurrency |
| The Closure Gotcha in Loops | 12. Closures & Iterators |
| The Gap Between Learning and Doing | 14. What's Next |
| The init() Function | 11. Modules & Packages |
| The Iterator Pattern in Go: Past and Future | 12. Closures & Iterators |
| The Standard Library Tour | 11. Modules & Packages |
| Type Assertions | 06. Interfaces & Type Assertions |
| Type Conversion | 02. Types & Variables |
| Type Switches | 06. Interfaces & Type Assertions |
| Unwrapping: errors.Is and errors.As | 08. Error Handling |
| var Declaration | 02. Types & Variables |
| Variadic Functions | 03. Functions |
| Walk the Directory | 13. Build a File Scanner |
| Weeks 1-2: Fluency (Stop Looking Everything Up) | 14. What's Next |
| Weeks 11-12: One Serious Project | 14. What's Next |
| Weeks 3-4: Real Tooling | 14. What's Next |
| Weeks 5-6: HTTP Services | 14. What's Next |
| Weeks 7-8: Concurrency Patterns | 14. What's Next |
| Weeks 9-10: Production Patterns | 14. What's Next |
| What a Slice Really Is | 07. Slices & Maps |
| What About context.Context? | 09. Concurrency |
| What Interfaces Are | 06. Interfaces & Type Assertions |
| What Pointers Are | 10. Pointers & Memory |
| When to Use Pointers | 10. Pointers & Memory |
| When You Need a Pointer to a Slice | 07. Slices & Maps |
| Wire It Up | 13. Build a File Scanner |
| Worker Pool | 09. Concurrency |
| Wrapping Errors | 08. Error Handling |
| Zero Values | 02. Types & Variables |