Thanks again for signing up for the workshop. There's a lot to cover and we'll need to hit the ground running on time so it's important that you arrive prepared with all you'll need locally already configured and ready to go.
- Have Git installed
- Have Go 1.13+ installed
- Have an editor/IDE with Go plugin installed.
- Have some basic familiarity with Go, use gobyexample.com if you need a refresher or introduction.
We'll be working from the command line quite a bit and you'll be expected to know how to navigate your file system in your preferred shell environment.
Use an editor/IDE with a Go plugin installed to help with syntax and hints. VSCode is recommended if you have no preference.
Action Item: Install VSCode
The workshop is about what your day-to-day work may/will be like and as such we follow these guiding principles:
- We put heavy emphasis on learning by doing.
- We link to online resources as needed so that you can refer to them on your own afterwards.
- If you can't find an answer in the material, search for it and we discuss what you find--yes, you can search StackOverflow or blogs, just like you normally would on your own.
- Don't be afraid to ask for help from the instructor or from a classmate--just like you might a coworker.
- There is often more than one way to accomplish a task so your solution may look different from the instructor's or classmates--and that's okay.
- If you spot a mistake in the material (the tech changes rapidly so it's possible), call it out and we'll address it in real time if possible. Seeing someone experienced troubleshoot can sometimes help us in turn.
The workshop is divided into sections with one or more topics. The typical workflow is as follows:
- Topic introduction
- Exercise
- Sample solution walkthrough
- Topic summary and/or related next steps
- You'll have access to the repositories, walkthroughs, and solutions.
- You can hit me up on Twitter if you have a clarifying question: @jboursiquot
- Must-know fundamentals: Go basic types and constructs; how Go does OO; syntax; common uses; gotchas
- Building tools: Building command-line tools; advanced language constructs such as pointers, structs, and methods; the Go toolchain
- Testing and interfaces: Testing in Go; how to use the standard library to write tests; techniques such as table-driven testing, subtests, benchmarks, and mocks using interfaces
- HTTP servers and clients: The fundamentals of building HTTP servers and clients in Go; handlers, multiplexers, and leveraging the context package for cancellation propagation; testing HTTP-based applications
- Modules and managing dependencies: Dealing with dependencies with Go’s module system to ensure repeatable builds; common usage patterns; tips and tricks of working with the Go toolchain to wrangle your dependencies
- Concurrency: How concurrency primitives work in Go; using Goroutines to do work; using locks to ensure exclusive access to shared resources; using channels to enable communication; when and how to leverage unbuffered and buffered channels; concurrency patterns in action
Depending on how engaged and active we are during class, we may not cover everything in depth but you will have access to the material afterwards and can reach out to the instructor with questions.