November 19th, 2023
Ultimate Service with Kubernetes
This class teaches how to build production-level services in Go with a focus on macro-level engineering decisions. From the beginning you will program along with the instructor, walking through the design philosophies and guidelines used to engineer the code. With each new feature, you will learn more about the transition from programming to engineering and the points of refactoring required to write production-level applications. Throughout the class, Go modules and Kubernetes will be a focus. Everyone will be making better engineering decisions after this class.
NOTE: according to the instructor, there will be two coffee breaks (one in the morning and one in the afternoon).
Modern Cloud Development with Service Weaver
This class teaches how to build distributed applications in Go with Service Weaver. At the beginning of the class, the instructor will walk you through the motivation behind Service Weaver and introduce you to the core abstractions that you need to know in order to develop a Service Weaver application. In the second part of the class, we will develop, instrument, test, and debug an emoji search engine application that will run in the cloud.
Pizza Hacking Night
November 20th, 2023
Keynote: State of the Go Nation
Go has come a long way in recent years, with a more productive, coherent experience than ever before.
In this talk, we'll review the latest advancements in the Go language and toolchain, and how the Go Team leverages its portfolio of projects to create complete, developer-centric solutions.
How Go taught me to love building apps again
Building apps is tough and involves lots of languages to reach multiple platforms - unless you build them with Go and let the tools do the hard work!
This talk covers the joy I experienced when starting to build graphical apps using Go and how any developer can feel the same with the Fyne toolkit.
Essential security checks for your Go project
Code security analysis, dependencies vulnerability scanning and supply chain security should be incorporated in the development process of any Go project.
In this talk, we will show how open source Go tools such as gosec, govulncheck and cosign make it easy to implement these security checks.
In the beginning it was about the metal, now is about the web: exploring webassembly in cloud environments
Thanks to its system interface (WASI), webassembly (WASM) is out loose and hitting the server side, the cloud native applications, the container world. And what's in common? All domains where Go runs strong.
Let's explore what we can do today and what's ahead, of course, using Go!
Understanding the successes and pain points of different testing strategies
Do you enjoy testing? Some say yes, some say no, but for most I believe the most ‘senior’ answer is ‘it depends’.
So, what are the variables that determine this? Culture? Code? Something else beginning with C? This is what I’ve spent the past few months investigating, so come join me and find out!
Go and Redis. More than a love story
What are two of the most desired characteristics when you develop software? Storage and Speed!
In this talk I will cover both of those topics and how they mix up! I will explain a simple Redis usage pattern and compare 2 of the most popular Redis modules in Go: GoRedis and Redigo.
Turning Git commits into changelog with Git-Cliff
Are you tired of updating the changelog file for each release of your project? Introducing git-cliff, the command-line tool written in Rust that aims to automate the process of generating your changelog based on conventional commits, saving you time and effort. Let's see how it works!
Boosting test coverage for microservices
Good enough test coverage enables truly continuous deployment. Unit tests get one so far, but integration tests with actual counterparties make more sense for some features. Measuring and monitoring the code coverage for the integration tests helps to achieve the ideal deployment pipeline.
Generating code in Go
Encourage good patterns, and improve developers experience through code generation. Telemetry, decorators, ORMs, schema-first approach - automate these chores, without increasing complexity, without runtime errors, without developer having to remember about them.
Building location-based recommendation systems using Google’s Geocoding and Go
As more and more applications rely on personalised user experiences, recommendation engines have become an integral component of modern systems. But how do these systems work on a database level? And why does it make sense to build them in Go?
Understanding the Go runtime
The Go runtime is an essential part of every single Go compiled binary. Understanding what it does for us and the price we pay for it can be interesting.
This talk will explore what the runtime does internally and what it provides to us.
Exploring Domain Driven Design in Go
Learn how to apply DDD to Go applications without compromising its unique idioms and language features.
This talk covers tactical and strategic patterns with real-world examples and best practices, making it ideal for DDD beginners and those who previously struggled to use it in Go.
lychee - Writing a link checker in a weekend (plus two short years)
Experience the quirky journey of building lychee, an async Rust link checker. From weekend project to a 2-year saga, it explores software development's underestimated complexities, open-source struggles, and funding nuances. Dive into the reality of creating robust tools. How hard could it be?
REST in Peace: using generics to remove REST boilerplate
Copy pasting boilerplate about HTTP handlers is exciting and funny for the first 3 webservices you code in Go. After that, it gets pretty annoying.
Generics provide a way to abstract that while keeping a strong type system.
RIP is an attempt to make REST in Go even simpler.
Give super powers to your Go application with WebAssembly and Extism
And why not take advantage of recognized Frameworks such as Fiber or Gin to create microservices based on WebAssembly? It is already possible thanks to the Extism project.
The job of Go maintainer
What does it mean to be a full-time maintainer? Last year, I left the Go Team at Google to become an independent professional open source maintainer. We'll talk about this experiment to establish a new more sustainable funding model for open source maintainers and how we can make it more accessible.
Social Event TBA
November 21st, 2023
The feeling of fast code
Can you feel the speed of your code? How do you optimize things that seem impossible to optimize? What are the acceptable tradeoffs for a speed increase?
There are a ton of questions when dealing with optimizing code. Let's try to structure our approach to writing fast code to get answers!
Towards modern development of cloud applications
We used Go to build a new cloud programming framework at Google. The way people use microservices to build distributed systems slowdown innovation and hinders application’s performance. Instead, the developer should split the code at logical boundaries and delegate execution challenges to a runtime.
Bring Gameboy alive in the Web with Rust and WebAssembly
Let's see how the heart of a Gameboy works by analysing the 8-bit microprocessor: Sharp LR35902. We will look at the behaviour of one of the CPU registers, memory and graphics processing of a Gameboy, consolidating this knowledge into writing an emulator for the Web.
GOing down the compilation rabbit hole
The Go programming language appears simple because the compiler handles the complexities of running them. This talk will examine the steps of compilation, divided into the front-end (Parsing, Tokenizing, AST Generation) and the back-end (AST to SSA conversion, Optimizations, Assembly).
Go beyond borders: building a cloud platform for global deployments in Go
How would you build a cloud platform to support global deployments?
After building a cloud provider in Python, we picked Go and the main open-source techs we're using are in… Go. Let's talk about building an engine to enable worldwide deployments of Go apps using BareMetal, Nomad, Kuma, gRPC & more.
Gophers like waiting in Postgres queue
As we as humans must stay in the queues for bananas, the Gophers should sometimes stay organised too. You may use various technologies for simple queueing, but you can also easily use Postgres too. Write the reliable consumers in Go on top of Postgres tables and keep your architecture simple...
Visually programming Go. Let's mix Blockly + Go and see what happens!
Join me in this experiment, we'll make some Go programs visually without writing a single line of Go code. I'll show some real life examples, talk about what could be done and what next!
From zero to func main: initializing packages
Go programs are often benchmarked, profiled, and optimized by looking at a particular workload. For CLIs and short-lived processes, getting to your “main” function as fast as possible is just as important - how do we measure and improve that?
Level UP your RDBMS productivity in Go
Developing with a database can be difficult, especially when dealing with typing issues, setting up a new database instance for testing, handling migrations, and other related tasks. By combining dbmate, sqlc, and test containers, we can effortlessly improve our database within our Go code.
My key takeaways from my 5-year experience of developing and maintaining two open source projects aimed at automating iOS devices
This is a story about how I reverse engineered Quicktime screen recording, Xcode test execution, built reverse engineering tools myself, created a small community for my 2 open source projects, stayed motivated for over 5 years and why Go was a great choice for all of this.
GoSecure: navigating security in Go
Hello! Are you interested in software security? Ever wondered how to implement the best security practices in Go? If so, you don't want to miss my upcoming talk. During this talk, we will demystify the complex world of software vulnerabilities by applying the latest tools for Go applications.
Scaling Coffee with goroutines
A step by step guide for introducing concurrency into an application by using goroutines and spinning out multiple deployments. Shown through the lens of how a coffee shop goes from tiny one person operation to a huge conglomerate. Friendly for all levels of programming and Go experience.
EBPF for the rest of us
EBPF is getting popular and popular. In this talk I will reintroduce it, and will describe what is the state of the art and how we can leverage it to solve problems related to performance, security and networking.
Getting the most out of dead code elimination
The Go linker optimizes the size of your binaries by removing functions that are never called, a process called "deadcode elimination". Some uses of reflection can, however, partially disable it. Learn how you can determine if your program is suffering from this problem and how you can solve it.
Structured logging for the standard library
Go 1.21's standard library features a new structured logging package, "log/slog". slog aims to be easy to use, flexible and fast. In this talk, I’ll describe the motivation for adding structured logging to the standard library, and I’ll cover the design and API of the package.
Level up your backend with Cucumber feature tests
I haven't run my backend locally for the past 5 years, and still never ship a broken API. How? Join me at GoLab and learn how to upgrade your test suite with Cucumber feature tests. Make changes, run the tests, and confidently push directly to production. Bonus: you get documentation for free.