10 Aha! moments exploring the go source code

In this talk I going to share my experience through the reading of the Go compiler/runtime source code. While I was reading the code and preparing talks like "Dissecting Slices, Maps and Channels in Go" or "Understanding the Go Compiler", I had some interesting "Aha!" moments. Thinks that clicked in my head, or given me an interesting insight about how the go programming language work.

In this talk we are going to explore 10 of that aha moments. Some of them is going to provide you better understanding of how the language work, some of them are going to make you more conscious about certain performance implications and some of them, maybe, can inspire you to build something new. But all of them catch my attention, and I think is going to captures yours.

The talk is going to cover in that 10 aha moments the following things:

- How slices are implemented (the underneath shared array between slices and subslices)
- The cooperative nature of the goroutines (As how channels work and how the goroutines park itself and wake up others, or how the scheduler ticks)
- The syntax of go (What the AST can represent and how that derives into what is possible to write in the language)
- Escape analysis + Inlining (How they collaborate to improve the performance)
- The SSA lowering (How most of the compiler is CPU architecture agnostic)
- SSA and tinygo (Tinygo leverage go SSA and LLVM to build microcontrollers binaries)
- The compiler/runtime tandem (How some part of the go syntax simply generates runtime calls)
- The main function is not the entry point (The runtime bootstrap is the entry point, your main function is called later)
- The Memory Allocator (What is it, and it works so efficiently)
- What makes the GC ticks (The memory allocations + the sysmon)

Deep dive in a SQL query

SQL is magical. As developers, we ask the database what we need, and the DBMS gives us results, but... what happens in between?

This talk is a walkthrough of the internal process that happens to our SQL query until we receive the results.

We will explore things like the query parser, the optimizer, the executor, and the cursors, with a certain degree of detail. Also, we are going to talk about how the query plan is executed.

This knowledge leads to a better understanding of how the database works and why our queries are sometimes slow.

Understanding the Go Compiler

The Go compiler is an excellent but complex tool. For most Go programmers, it’s just that - a tool. It doesn’t matter what happens between my "go build" and the execution of my binary because the go compiler works like a charm. But if you are a curious person that wants to know more about this process, this is probably your talk.

I’ll go through the whole process of the compilation of one of the most straightforward go programs that you can write: a hello world. From that source file, with just plain text, into an optimized machine-specific binary code, passing through the transformations in between.

Understanding the go compiler

The Go compiler is a great but complex tool. For most Go programmers it’s just that, a tool. It doesn’t matter what happens between my go build and the execution of my binary, because, at the end of the day, the go compiler works like a charm. But if you are a curious person that wants to know more about this process, this is your talk.

I’ll go through the compilation of one of the simplest go programs you can write: a hello world. From that source file, with just plain text, into an optimized machine-specific binary code, passing through the set of transformations that happens in between.

The secret life of a goroutine

Goroutines are an exciting part of the Go language, but what are they? How are they created? How are they paused? How are they resumed? There are a lot of questions that the regular go programmer doesn't need to know and usually doesn't know, but if you, like me, are a curious person, you probably want to know more about what is going on under the hood.

Come with me on this interesting trip through one of the most outstanding features of the Go language, the goroutines, and discover what makes your Go programs tick!

Squeezing a go function

Performance is great. But sometimes, knowing what is consuming my memory or CPU is hard. Sometimes it is obvious, but sometimes it is subtle. Sometimes it is not clear what "performance" means in certain contexts.

In this talk, I want to introduce the concept of performance optimizations, benchmarking, and profiling. Where, when, and how to do them in a consistent and repeatable way. Then I will focus on micro-optimizations in Go, following a set of examples and explaining the reasons behind them.