Go Workshop Plan

Unlike last year, this year we want to split the main Go workshop into 2 separate roughly 2 hour workshops, the first workshop will cover Go fundamentals while the second one will focus exclusively on design patterns, testing and concurrency in Go. The second workshop is only really meant for the CMS team but others are welcome to join if they are interested.

The first workshop is also further divided into two parts, the first part aims to provide a strong cursory overview of the language (syntax, features, quirks and whatnot) while the second part aims to provide a deep dive into the language for those that are interested (I’ve chosen a set of selected topics that I think will be interesting to talk about). The only actual part with important content will be the first part while the second part is more “interesting trivia“.

First Workshop (2 hours 15 mins)

• Part One (1 hour 25 mins)

  1. Introduction basically talking about what Go is, who uses it and why use it (without triggering Rust people), $GOROOT and how to setup Go (10 mins)

  2. Syntax (similarities with C) as well as basic language constructs (if statements, switch statements, for loops, functions, etc…) (15 mins)

  3. Language Quirks (weird Go specific syntax like initialization in an if condition ) as well as more advanced language constructs (structs, interfaces, memory allocation + heap escapes) (15 mins)

  4. Data structures (language specific data structures such as: arrays, slices, maps) (10 mins)

  5. Advanced Go basically talking about harder Go concepts such as:

     1. Functions as first class citizens, closures, deferrals (10 mins)

     2. Generics and type constraints (10 mins)

     3. Inheritance, struct embedding, polymorphism (10 mins)

  6. Package and dependency management basically talking about Go modules and how to structure a Go project (5 mins)

Oh my lord that’s a long part one, so insert a 10 minute break before moving to the second part. Most people are free to drop off after part one as part two is just covering a lot more of cool nitty gritty details of Golang which I thought would be cool to covert, basically its just a list of selected topics

• Part Two (40 mins)

  1. The Go runtime (what is it? why is it? how is it? hopefully its having a great day), memory allocation and garbage collection (10 mins)

  2. Slices and maps: under the hood… how do they work? Glorified pointer thingy mabobs (10 mins)

  3. Interfaces: under the hood… how do they work? Method dispatching (10 mins)

  4. Constraints vs Interfaces whats the difference? Go now uses interfaces to specify a constraint on a generic type so I feel like this is an important topic. (10 mins)

So that’s the first workshop… It’s quite packed so I really apologise; it is of course subject to change if ya’ll feel like there is too much content. If we need to cut stuff I feel like we can cut stuff out of to the Advanced Go part of part 1.

The second workshops is tailored entirely towards the CMS team and covers stuff that they will hopefully be using on a daily basis, everyone else is free to join however its unlikely they will find much use out of it .

Second Workshop (1h 55 mins)

• Part 1 (The boring stuff) (40 mins)

  1. Revision covering all the stuff from the past workshop real quick (10 mins)

  2. Basic design patterns in Go (tbh I really just feel like going through refactoring Guru for this part ) (15 mins)

     1. Singleton

     2. Factory

     3. Decorators (we use this extensively within our endpoint package)

     4. Repository Pattern

     5. Bridge

     6. (Not a design pattern) Inversion of Control

  3. Unit testing in Go (go:generate, gomock and mocking interfaces) (15 mins)

• Part 2 (concurrency) (1h 15 mins)

  1. CSP and the Go model of concurrency (go-routines, channels) (20 mins)

  2. Synchronisation Primitives and Synchronisation via communication (20 mins)

  3. The Golang Race condition + Deadlock Detector (5 mins)

  4. Fun with channels (implementing semaphores, buffered channels, how to deadlock your go-routines etc) (10 mins)

  5. More on concurrency (select statements, the event loop (as used within the CMS), wait groups, some concurrency patterns) (20 mins)