Production Ready Hello World

As software engineers most of the time we are focusing on delivering the task that is given to us. If someone asks us to do a hello world API we can do it in 4, maybe 5 lines of Go code, but would that code be production ready? What does production ready code actually looks like? In this talk we are going to implement a “hello world” API, but focusing on all the aspects that would make this code production-ready, including documentation, logging, error handling, configuration, naming, code organization, testing and others.

I’ll start with a bit of theory and then progress to do a live coding session starting from the 5 liner hello-world code and step-by-step progress to something that is more production ready. I can adapt the content to take anything from 25 to 45 minutes.

Slides from a previous version of the talk can be seen here: https://docs.google.com/presentation/d/e/2PACX-1vRv0ucp_9yrOLdJNiWma1FZolEcEGmdznZvSC_NLrLGOGlcczL1wIh4A-5i6s6Xj6X8hJaYE7XjVqtC/pub?start=false&loop=false&delayms=3000&slide=id.g56441dcac2_0_14

Fun with Slices

Slices can be seen in almost every Go program, but many developers are still unware of how they exactly work.

On the surface we might think they are simple constructs that allows us to handle multiple elements of a single type, but they are more than just a collection.

Specially for people new to Go, slices can be a source of pain because of the behaviors it possess that you wouldn't expect from a traditional dynamic array or list.

In this session we are going to do a deep dive on the slice type, starting from arrays and slice declaration syntax, slicing operations, copying, resizing and its surprising (or not) side effects.

The session will be composed most of code examples using the playground, with an eventual dive into the compiler source code to see the relevant bits of slice implementation.

Fun with Generics

It has been over two years since generics were introduced in Go. Have you done anything fun with it? I have! Ever since the "Creative Use of Generics Contest" at Gophercon 2021 I have been dreaming with a monads library implementation in Go. In this session I will walk you through the basics of generics, how I used it to build a monads library, the challenges, limitations and a comparison with non-generic Go. In the end, you will be the judge to the question: was it a good idea after all?

Topics include:
- Generics syntax: types, functions, interfaces
- Generics constraints
- Monads: what they are, what they eat, where they live
- An Option type implemented in Go

Who test the tests?

If tests are meant to guarantee the quality of our code, have you ever questioned yourself who is responsible for guaranteeing the quality of our tests?

In this talk we will explore the concept of mutation tests, technique designed to ensure that your tests are working as expected - or in other words - the test of your tests.

Mutation testing involves automatically rewriting the code in a way that breaks the unit tests - this is what we call a mutation. If after rewriting the code with a mutation the tests are still passing it means the tests are not catching that mutation. After trying several mutations in a row, a test that survives them all without breaking might not be testing anything after all!

The talk is structured as follows:
1. Introduction: what is mutation testing? (5 min)
2. How to programmatically rewrite code in Go, including a gentle introduction to Abstract Syntax Trees (10 min)
3. How to use compiler overlays to replace files during compilation time (5 min)
4. Combine previous steps to perform a conditional mutation (10 min)
5. Current state of mutation testing in Go (2 min)
6. Conclusions and final words (2 min)

Talk code will be based on: https://github.com/danicat/selene

Fun with Memos

When was the last time you had to "memoize" something? Whether you are cracking your head studying for the next coding interview, or are trying to squeeze that last drop of performance from your APIs, memoization is an important performance optimization tool for trading off space for speed.

Go makes it really easy to memoize things using the built-in map data structure and it became even more powerful with the adoption of generics.

In this talk we are going to explore:

- The map built-in
- What is memoization?
- What can be memoized?
- Differences between Pure and deterministic functions, side effects and side inputs
- How to implement a generic "memoizer"
- Concurrency considerations using memos