Program
The largest official gathering of the year, RailsConf brings together top talent, companies, and project representatives from around the world. Learn and build with the best in sessions, workshops, keynotes and parties.
Laying the cultural and technical foundation for Big Rails
As applications built on Rails get larger and larger, and more and more engineers work in the same monolith, our community needs to think more about what sort of tooling and architectural changes will help us continue to scale. This talk shares ideas around a toolchain, and more importantly, the social and cultural programs needed to support that toolchain, that can be used to help engineers in an ever-growing Rails codebase continue to have high velocity, manage their complexity, and claim ownership over their own business subdomains.
PlayLet Your Body Lead: Career Planning With Somatics
How do you build a career you love? As engineers we try to make choices based on data, metrics, research. We make spreadsheets and “Compare Features.” And yet...so often we end up unhappy. All that careful research somehow doesn’t help.
But what if you made decisions a different way? What if you had a sophisticated decision-making apparatus to guide you, built precisely to your needs -- an always-available guide?
You do! It’s called your somatic intelligence. With practice you can learn to tune into it and let your body lead the way to satisfaction and fulfillment -- in every area of your life.
Upgrading Rails: Everyone can do it and here’s how
Ever felt overwhelmed when figuring out how to upgrade a Rails app? Unsure where you should begin? We’ll talk about how upgrading should be treated as a feature, and how you can get buy-in from management for upgrading Rails. Have you heard about how GitHub or Shopify uses dual-booting to run two versions of Rails at once and wondered how that works? We’ll talk about three approaches you can use to upgrade your app. You’ll leave this talk with takeaways you can put into practice for your next Rails upgrade.
Puny to Powerful PostgreSQL Rails Apps
This talk covers 5 challenging areas when scaling Rails applications on PostgreSQL databases. From identifying symptoms to applying solutions and understanding trade-offs, this talk will equip you with practical working knowledge you can apply immediately. This talk covers topics like safe migrations, understanding database connections, query optimization, database maintenance, and database replication and partitioning.
Computer science you might (not) want to know
One common recommendation for aspiring software developers is to pursue a degree in Computer Science (CS). While CS curricula do often cover practical software development skills, many departments heavily prioritize more academic and theoretical topics. This begs the question: how relevant is a CS degree to the day-to-day work of a professional developer?
We’ll look at a few topics that are often included in the first half of an undergraduate CS curriculum. We’ll examine this information through two lenses: why it can be helpful and why it might not be all that relevant for a typical Rails dev.
The Mrs Triggs Problem
"That's a good suggestion Mrs Triggs, perhaps one of the men in the room would like to make it?"
As a society we have an attribution problem. People who look like me get it easy. Join me to explore how we can push back on the default stories & myths of who is providing value in our community.
Warning, may contain content that will make you uncomfortable about your own past behaviour. But you'll leave better able to provide a better industry for your fellow humans.
Gem install: What could go wrong?
The open source gem ecosystem is a major strength of Ruby and it’s not uncommon for a production Rails application to depend upon hundreds of gems. But what are the risks of installing a gem and having it in your Gemfile?
In this talk, we’ll cover what “bad things” can actually happen when you install a gem. We’ll also talk about the ways of preventing these attacks from occurring in your application dependencies (so you can sleep well at night).
Getting Good Ideas Adopted
One of the most rewarding aspects of being a software engineer is seeing our ideas transform from thought into working code. But what if our team (or manager) doesn't think an idea is good? It's frustrating to propose a solution and have it rejected. So what do we do? What are some ways we can help our teams and bosses more clearly understand our vision? How can we de-risk technical change to be less controversial? And importantly: how do we do this collaboratively and productively? We'll talk about technical and interpersonal strategies we can use to help get our good ideas adopted.
Cultural Fit + Culturesmithing: Everyone Influences Culture
“Toxic culture” is, by far, the number one reason that people are quitting their jobs. People are no longer willing to work at organizations where they don’t feel valued, respected, and included. Economists have dubbed this “The Great Resignation.” In this talk you will learn how this situation applies to you and what you can do to make things better. You will learn a framework for evaluating whether an organization’s culture meets your personal needs, and you will learn 20 immediately implementable techniques to improve this culture.
From reactive to proactive, an accessibility journey
What is proactive accessibility? Learn about the transformation process, and take away lessons learned from the push and pull in getting a company to adopt change.
Dive into real processes and practices that you can begin using on your teams today, whether it is grassroots or top-down driven, and how those help you become more effective.
Scaling Rails with JRuby in 2022
JRuby is back in 2022 with Ruby 3.1 support and new work on performance and scaling. For over a decade, Ruby users have turned to JRuby to get access to world-class garbage collection, native JIT compilation for increased performance, and true parallel threading. Today, you can take your Rails app and reduce both latency and resource costs by hosting a single JRuby process for all your concurrent users. JRuby is the only alternative Ruby deployed at scale, powering companies all over the world in mission critical areas. Come see how JRuby can help you scale today!
Learn it, Do it, Teach it: How to Unstick Our Middle Devs
One definition of the middle: a difficult or unpleasant position. Yuck! It certainly can feel that way for mid-level developers. Fortunately, we've uncovered a model that will help managers create an environment where their devs can thrive. Our Learn it Do it Teach it (LDT) model will foster more learning, while keeping their hands on the code, and adding in the magic touch, teaching. This talk will demonstrate how managers can implement a LDT model into a developer’s day to day. Growth plans like this model will allow your team to move from mids into seniors both faster and more confidently.
Your TDD Treasure Map
We know testing is vital and makes refactoring painless. But how to set sail to that TDD treasure? Yarr, we need to test to get experience, but need experience to test. Let’s draw a map with simple strategies for identifying test cases and building a robust test suite. X marks the spot w/ TDD tools for newbies and seasoned pirates alike.
Don't page me! How we limit pager noise at New Relic
New Relic's largest monolith handles 200k req/min and communicates with >40 external services and 11 mysql databases; this should result in constant downtime. Being mindful and alerting on the right things has been critical for us.
This talk will cover a successful process for identifying trustworthy data, refining alert conditions, and what kinds of checks to page on.
Unboxing Rails 7: what's new in the latest major version
Rails 7.0 removes webpacker and spring from the default stack, adds encrypted attributes, allows for asynchronous query loading, changes autoloading defaults, attaches comments to Active Record queries, and introduces new tools for front-end development.
Learn about these and many other Pull Requests that were merged in rails/rails in 2021. Understand the motivation behind some architectural decisions. Review the process to upgrade from Rails 6.1 to Rails 7.
"Build vs Buy" on Rails
Your SaaS app is adding new engaged users every day and your roadmap is growing with features to delight them! Users are requesting new 3rd party integrations, more powerful search, reporting capabilities, and live chat, oh my!
Should you try and build all of these features? Should you work with partner services to add these features? The answer: it depends!
In 2022, the classic "Build vs Buy" question is more nuanced than ever and we'll dig into the pros and cons when building (or buying) on Rails.
A Rails performance guidebook: from 0 to 1B requests/day
Building a feature is not good enough anymore: all your work won't be of use if it's not performant enough. So how to improve performance? After all, performance is not an easy discipline to master: all slow applications are slow in their own way, meaning that there is no silver bullet for these kinds of problems.
In this presentation, we will guide you across patterns, strategies, and little tricks to improve performance. We will do that by sharing real stories of our daily experience facing and solving real performance issues in an application that daily serves billions of requests per day.
Reflecting on Active Record Associations
Active Record associations seem magical—add a has_many here, a belongs_to there, and suddenly your models are loaded with behavior. Could it be magic, or is it plain old Ruby with some thoughtful design and a bit of metaprogramming? In this talk we'll study Active Record associations by writing our own belongs_to and has_many macros. We'll dynamically define methods, cache query results, replace a a Relation with a CollectionProxy, and automatically prevent N+1 queries with inverses. You'll leave with a deeper understanding of associations, and a new appreciation for their magic.
Your Service Layer Needn't be Fancy, It Just Needs to Exist
Where would you put your business logic if not in Active Records? The answer is a service layer. Your service layer provides a seam between your user interface and your database that contains all the code that makes your app your app. This single design decision will buoy your app's sustainability for years. You'll learn why this is and how to start a service layer today without any patterns, principles, or fancy libraries.
Functional Programming in Plain Terms
Have you ever wanted to know what a monad is? How about a functor? What about algebraic data types and parametric polymorphism? If you've been interested in these ideas but scared off by the language, you're not alone: for an approach that champions composing simple pieces, functional programming is full of complex jargon. In this talk, we'll cover these topics from a Ruby and Rails perspective, composing small ideas in everyday language. Before we're through, you'll have a rich new set of FP ideas to apply to your projects—and you'll finally learn what a monad is (hint: it's not a burrito).
GraphQL and Rails beyond HTTP APIs
Are you considering building a GraphQL API for your Rails project or already have one? Do you know GraphQL can be leveraged beyond HTTP APIs?
We will explore how GraphQL does not depend on HTTP and can be used as a secure and structured data layer for Rails projects. You will learn to deliver real-time GGraphQL through Websockets, Webhooks containing all the data you need, provide data for WebAssembly code and parallelize queries exporting large amounts of data. Every Rails project needs consistent access to data and GraphQL brings solutions beyond the typical HTTP API.
Ooops! You named it wrong. What now?
You hear everybody talk about the newest feature to Widgets but you can’t find a single model reference to that in the code. What happened? Sometimes the business changes aren’t reflected in the code. Sometimes, you're missing information or the code grows into something different. What do you do? ‘Cuz you still gotta ship.
Buckle up for a fast paced ride through the opportunities and pitfalls faced when you find yourself in this position. Through success and failure stories, learn how to leave space for names to breathe, make changes safely, and walking that fine line of changing just in time.
Call me back, Postgres
Rails' Active Record callbacks provide a simple interface for executing a process when something happens to a database record. However, sometimes Active Record callbacks aren’t the best solution available. For those cases, this talk introduces a great alternative: Postgres' trigger functionality, a way of implementing callbacks at the database level. Coupled with Postgres' listen and notify features, you can develop creative solutions for making your Rails app the center of an otherwise complex system, managing data syncing and other processes seamlessly, regardless of consumers of the app.
If You Know Heroku, You Can Use Kubernetes
You've probably heard "Kubernetes is overcomplicated! Just use Heroku!" But it turns out that, while Kubernetes can be complicated, it doesn't have to be. In this talk, you'll learn how to deploy with Kubernetes in a way that is nearly as friendly as with Heroku.
Your test suite is making too many database calls!
On a recent project, I sped up a test suite 15% by making a change to a single factory. This suite, like many others (including yours!), was making way too many database calls. It’s so easy to accidentally add extra queries to factories and test setup and these can compound to shockingly large numbers.
The chaos is your opportunity! Learn to profile and fix hot spots, build big-picture understanding through diagrams, and write code that is resistant to extraneous queries. This talk will equip you to take back control of your build times and maybe impress your teammates in the process.
Experimental Patterns in ActiveRecord
ActiveRecord provides a great deal of flexibility and speed of implementation for developers making new apps. As our teams and codebase grow and our services need to continue to scale, some of the patterns we use can start to get in our way. We've seen a bit of that at GitHub, and as a result have been experimenting with some new ways to work with ActiveRecord queries, reduce N+1s, and isolate model details.
In this talk, I'll go over some the problems we've been facing, cover how we've been addressing them so far, and show some new experiments & patterns I've been working through.
Do You Trust Me?
I've got a deal for you. You give me some trust, I'll give you some time back. No strings attached.
Trust is core to working on a team. We give a little trust, so we can save time. We use systems to create/protect/and outsource trust: PRs, pairing, code cov, type systems, etc. Join me for an exploration of trust in engineering, the psychology of trust, its relationship to time, and how we can have better trust rituals when we reframe the goal. So give me a little of your time and I'll teach you a little about trust. Do we have a deal?
The Queue Continuum: Applied Queuing Theory
A Star Trek themed exploration of queuing theory and scaling applications with parallelism and concurrency. A general overview of the differences between parallelism and concurrency as well as when to apply more threads or more processes. We’ll go over examples of sidekiq and puma with different concurrency settings in various IO scenarios.
Geolocation EXPLAINed
How do you find the location of someone visiting your site? And, how do you do it fast? If you've ever been curious about how analytics services can place your site visitors on a map, or about how to analyze and improve a slow running query, then this talk is for you!
In this session, you'll learn about IP address networking, fundamental database operations, and query performance tuning. We'll develop a geolocation system from the ground up, and make sure it's running lightning fast along the way.
Service Denied! Understanding How Regex DoS Attacks Work
Did you know that people can knock your Rails application offline just by submitting specially formatted strings in a form or API request? In this talk, we’ll take a look at what’s really going on with a regex denial of service (DoS) attack. We’ll take a peek into the CRuby regex engine to see what it’s really doing when we ask it to match against a string. With a basic understanding of how regular expressions work, we can better understand what these attacks do, why they tie up so much CPU, and what we can do to guard against them.
Browser History Confessional: Searching My Recent Searches
We all only have so much working memory available in our brains. Developers may joke about spending their day composing search engine queries. The reason it's a joke is because of the truth behind it. Search-driven development is a reality.
Join me, and my actual search history, on a journey to solve recent challenges I faced. I'll categorize the different types of information I often search for. You'll leave with tips on retrieving the knowledge you need for your next bug, feature, or pull request.
Testing legacy code when you dislike tests (and legacy code)
Are you supporting legacy code? Would you like to stop? A good testing strategy can transform legacy code into living code that is resilient and easy to evolve.
Learn why legacy code is so difficult to maintain and identify where tests can make the most impact. Not just any tests, though! We'll dive into the characteristics of high-value versus low-value tests and learn techniques for writing tests that minimize the cost of change.
Developers of any experience level can benefit from these concepts. Familiarity with Rails and an automated testing framework is helpful but not required.
A Rails Developer’s Guide To The Ruby VM
What happens under the hood when you run a Ruby script as simple as puts “Hello World!”?
Time to switch gears from the Rails-level of abstraction to a lower one and dive into some Ruby internals. We’ll be learning about how the Ruby code you write gets compiled and executed, then zoom in to the VM-level – what VMs are and what they do, and how the Ruby VM works. You’ll walk away with a better understanding of how Ruby and Rails works as a whole. No low-level systems knowledge needed!
Come on in! Making yourself at home in a new codebase
"Welcome! We're so excited to have you 🤗 please excuse the mess." – if a codebase could talk
When we join a new team or start a new project, we have to onboard to the codebase. Diving into code that we're unfamiliar with can be stressful or make us feel like we don't know what we're doing. And the longer the codebase has been around, the more intense those feelings can be. But there are steps we can take to understand new code and start contributing quickly. In this talk, we'll cover how to build our code comprehension skills and how to make our own code welcoming to guests in the future.
The Little Engines That Could
Rails Engines. It’s more than just a cute name made up of two words both related to trains.
Are they plug-ins? Are they microservices? When do we use them? How do we implement them? Why aren’t they used more often?
Those are the questions I wish were answered for me when I first learned about Rails Engines. Inspired by Wired’s Explain In 5 Levels series, we will explore Rails Engines and address these quandaries using a variety of techniques, breaking down what engines are and how and when to use them.
RAILS_ENV=demo
Today’s the day. You’ve prepared your pitch, deployed a special copy of your app, and confirmed—in a trial run—that your walkthrough is ready for a live audience. But, now, when you attempt to log in, something breaks. Flustered, you debug, apologize, and debug some more, before finally calling it quits. Next time, you’ll bring a prerecorded screencast... 😮💨
What could’ve been done to make the app more reliably "demoable"? Join us, as we use "stateful fakes" and "personas" to produce a testable, maintainable, and failure-resistant "demo" deployment, with production-like uptime guarantees!
Ruby Archaeology
In 2009 _why tweeted: "programming is rather thankless. you see your works become replaced by superior works in a year. unable to run at all in a few more."
I take this as a call to action to run old code. In this talk we dig, together, through historical Ruby. We will have fun excavating interesting gems from the past.
Further, I will answer the following questions:
- What code greater than 12 years old still runs in Ruby 3.1?
- What idioms have changed?
- And for the brave: how can you set up an environment to run Ruby 1.8 code from ~2008 on a modern machine?
Pictures Of You, Pictures Of Me, Crypto Steganography
I was puzzled when a friend sent me a Buffy the Vampire Slayer picture out of the blue but, knowing that friend is an oddball, thought nothing of it. Days later, again without warning, a Babylon 5 picture. A few days after that a picture from Firefly. Then he repeated the pictures. A cryptic comment led me to understand that there was more to them than met the eye. Come learn the history, applications, and math behind crypto steganography how unravelling the mystery of the pictures culminated in the resolution of a 15 year rivalry when the US Olympic men’s curling team won the gold in 2018.
O(1), O(n) and O(#$*&!)
Reasoning about the performance of your code doesn't need to require a PhD in computer science or specialized tooling - We'll learn how to quickly recognize and diagnose common performance issues like excessive algorithmic complexity and IO waiting using OpenTelemetry compatible tools. Then we'll fix those issues, and ensure that they stay fixed using automated performance testing, even as your application grows.
How music works, using Ruby
That strange phenomenon where air molecules bounce against each other in a way that somehow comforts you, makes you cry, or makes you dance all night: music. Since the advent of recorded audio, a musician doesn't even need to be present anymore for this to happen (which makes putting "I will always love you" on repeat a little less awkward).
Sound engineers have found many ways of making music sound good when played from a record. Some of their methods have become industry staples used on every recording released today.
Let's look at what they do and reproduce some of their methods in Ruby!
Leveling Up from Planning to Production
The biggest difference between a mid-level engineer and a senior engineer is the scale and scope of the work they're responsible for. How do you dive into complex tasks, report progress to project leadership, and stay focused with so many unknowns?
These are the questions I've continued to ask myself as I grow in my career. In this session, we'll explore the tools myself and other senior-level individual contributors use to shape our work from project inception to delivery.
The pitfalls of realtime-ification
Building realtime applications with Rails has become a no-brainer since Action Cable came around. With Hotwire, we don't even need to leave the comfort zone of HTML and controllers to introduce live updates to a Rails app. Realtime-ification in every house!
Switching to realtime hides many pitfalls you'd better learn beforehand. How to broadcast personalized data? How not to miss updates during connection losses? Who's online? Does it scale?
Let me dig into these problems and demonstrate how to resolve them for Action Cable and Hotwire.
Don't touch that!
Ruby on Rails is a huge framework. There are modules, classes, established conventions, and a slew of code that's meant to be off-limits. But, what if we took our ornery childish self and played around? This is a talk about strategies for debugging, taught through the lens of experimentation and childish play. In this talk, we will override, extend, and disable all sorts of Rails internals and see what happens.
ELI5: A Game Show on Rails
‘Those who know, do. Those that understand, teach.’
We might know our way around the classic conventions of our beloved Ruby on Rails, but do we understand them enough to explain those concepts to our peers? In this interactive (participation optional!) game show session, let’s find out!
After we quickly discuss some of the philosophies of teaching, we’ll divide up into teams and play a Jeopardy! meets Catchphrase hybrid game… with a few surprises along the way! Beginner, intermediate and advanced Rails-devs are welcome, and Portland-themed prizes will be awarded to the winners.
Spacecraft!: Maintaining Rails apps for fun and profit
Join us for an allegorical journey aboard the spacecraft Legacy, where the astronauts desperately need to update their aging infrastructure. Their leader, a brave spaceperson named Yuki, knows these repairs must be completed before the team gets hit by a series of feature request asteroids. This talk is an ELI5 journey through the various strategies around assessing, improving, and bullet-proofing Rails apps in need of some cosmic maintenance.
Hold my thread: concurrency in Ruby
JavaScript has async and Ruby has…what exactly does Ruby have?! What is the difference between parallel, concurrent, and asynchronous execution of programs? If you have asked yourself these questions, this talk is for you! Together, let’s dive into the world of concurrent execution of computer programs. We’ll explore the vocabulary, general concepts, and inner workings of a computer before we dive into Ruby’s specific implementations of concurrency in its various forms. Finally, we will look at performance improvement considerations and shed light on the pros and cons of concurrency.
Rails C With Me: The Interactive Console As A Superpower
Spinning up the rails console can be a quick way to answer a question with a back of the envelope calculation. But, what else can we use it for, and how does it work? Allow me to show you new ways to leverage the console's features and become an even more expert debugger. You'll leave with some simple tactics to save you time and write more performant code. While you're here, we'll look under the hood to see how the features of the console are encoded and we'll trace back the history of these libraries to see how they arrived in our Rails application.
Event Streaming on Rails
Pop quiz: How do you best make one Rails app communicate with another? How do you split one big Rails app into two smaller ones? How do you switch from a Rails app to a constellation of Rails services? Event streaming provides the most robust answer. Simple but powerful Kafka streams unlock a world of capabilities with their durability and consistency, but integrating with Rails poses challenges. Join us and learn simple reading and writing to Kafka with Rails, broader distributed systems design, and the magical transactional outbox. You'll leave with the knowledge you need to make the switch.
Kuby: Active Deployment for Rails Apps
One of the Rails mantras is "convention over configuration," sane defaults that limit the cognitive overhead of application development. It's easy to learn and easy to build with... right up until you want to deploy your app to production. At that point, the hand-holding ends. Like the Roadrunner, Rails stops right before the cliff and lets you, Wile E. Coyote, sail over the edge. We have active record for interacting with databases, active storage for storing files, etc, but where's active deployment? Come learn how Kuby, a new deployment tool, is trying to bridge the gap.
Caching Without Marshal
Marshal is Ruby's ultimate sharp knife, able to transform any object into a binary blob and back. This makes it a natural match for the diverse needs of a cache.
But Marshal's magic comes with risks. Code changes can break deploys; user input can trigger an RCE.
We recently decided these risks were not worth it. Breaking with convention, we migrated the cache on our core monolith to MessagePack, a more compact binary serialization format with stricter typing and less magic.
In this talk, I'll pry Marshal open to show how it works, how we replaced it, and why you might want to do the same.
React-ing to Hotwire
I was fully onboard with React as my front-end Javascript framework of choice for years. That all changed when I suddenly had to support a stand-alone React app that I had no hand in building. Thankfully Hotwire had just been released, and my manager was aware of how painful maintaining this application was going to be. So I started the process of migrating the React app into the Rails app, using Hotwire as the new front-end framework. How did it go, what lessons were learned, and would I do it again?
Breaking up with the bundle
Over the course of 14 years, the GitHub.com CSS bundle grew to over 40,000 lines of custom CSS. It became almost impossible to refactor. Visual regressions were common. In this talk, we'll share an honest picture of our successes and failures as we've worked to break up with our CSS bundle by moving towards a component-driven UI architecture.
Behind the Lemurs - Creating an Illustrated Talk
Perhaps you've heard of a magical band of cartoon lemurs with a love for teaching Ruby, but what exactly goes into making one of these talks? We'll look at my entire toolset and process for creating illustrated conference talks including ideation, storyboarding, art, code tie-ins, and more. Perhaps you'll even learn to make a few lemurs of your own!
Start Your Ruby Podcast Today! No Experience Required
In 2018 a hot new Ruby meetup appeared online. 🔥 Three meetups later, it was gone. 😭
This failed experiment paved the way for a new Ruby podcast: Remote Ruby. 170 episodes later, we've learned a lot! We had no previous experience podcasting before the first episode. Along the way we've learned things like what kind of gear to use, how to perform interviews, and affirmed just how lovely the Ruby community is.
It's your turn! Come to learn from our mistakes, leave ready to start a podcast!
Git your PR accepted. Rebase your changes like a pro
You want to contribute to an Open Source project, and you have a complex PR to submit. You've tried to keep it small, but sadly getting there took a lot of effort and your branch has more than 30 commits with fixes and reverting of dead ends.
You know reviewing this will be a nightmare for the project maintainers, and more importantly, it will be almost impossible for anyone in the future to understand what you did by looking at the history.
In this talk we will look at how Git branches work, and how to manicure them using Rebase to build a commit history your colleagues will love you for.
Open the gate a little: strategies to protect and share data
Can you name a more terrifying set of three words in software development than "HIPAA violation fines"? I bet you can't.
We know we know we must protect access to our information at all costs, sometimes we need to provide access for legitimate reasons to our production data and this brings a dilemma to us: how to do it while minimizing the risks of data leakage.
In this talk I'll share some strategies that can give you some guidance on when to close the door, when to open the door and when to open the door to your information a little