Talks & speakers

Building a multi-user reservation system across Hotwire and a Rails API

Building multi-user reservations for appointments, tickets or other limited resources is such a classic problem that it comes up in system design books as “Build a ticket reservation system”. What do you need to know to build it for real? I will share my experience: from building a simple MVP, planning how to scale it, and designing for reliability and recoverability in a distributed system.

Running Native Extensions and Ruby Code in Parallel Threads

Ever heard of the one-lock-to-rule-them-all preventing parallel execution of Threads for both Ruby code and native extensions? Let’s remove that!

In this talk we show how we are running native extensions in threads running in parallel, what conditions are needed for that and how to make your own native extension compatible with parallel execution.

We also look at what it takes to run Ruby code in parallel, including making Hash parallel, thread-safe and fast.

This is using Threads and not Ractors, so it’s compatible with most gems without changing the programming model.

The database diet that slimmed down our codebase too.

Sysadmin: We need to reduce the size of our database.

Me: Ok, we’ve done that before. I’ll just delete a few million records from the database as we did last year.

Spoiler: I didn’t delete a single row. This is the story of how we cut our indexes by more than 60% through proper database design and maintenance instead. Chasing down why those indexes existed took us straight into the Ruby code, uncovering some dead code. Expect PostgreSQL techniques you can apply on Monday morning.

Regex as Easy as /(abc)?/

What really happens when Ruby sees a regular expression like /abc/? While many of us use regular expressions regularly, we don’t necessarily think much about how they really work. In this talk we’ll trace a regular expression through Ruby’s internals, from parsing the pattern into a syntax tree, to compiling into bytecode, to executing that bytecode on a small virtual machine. You’ll come away with a deeper understanding and appreciation for Ruby’s regular expression engine, and hopefully an increased confidence in working with regular expressions in Ruby.

Mirrors Don't Have Opinions

Every system we build reflects something back at us. Our strengths, our blind spots, the things we never thought to question. We’ll look at what the mirror actually shows, how it turns up in everything we ship, and how to make the reflection something worth looking at.

It Works, but There’s Something Off

In this talk we’ll discuss a bunch of things in Ruby and Rails that work in practice and we may be used to them, but that if you consider them carefully there’s something off about them. It will be an exercise in interface design, and also a way to show beginners even mature software and seasoned Ruby developers may not always get it all nice and round.

From Rails 3.0 to Rails Edge - 15 years of Rails upgrades in a 3 million line monolith

Fin has been running on Rails since 2011. Starting from Rails 3.0, today our 3 million line monolith is running on the main branch of Rails. This talk covers our Rails upgrade journey over the last 15 years - the things that broke, the monkey patches keeping it all together, and what it takes to get 300 engineers comfortable shipping on unreleased Rails versions.