---
# System prepended metadata

title: 'Gradually Typing Your Rails Application: The Easy Way'
tags: [CFPs]

---

---
title: "Gradually Typing Your Rails Application: The Easy Way"
description:
tags: CFPs
---

# CFP Template

## Title

Gradually Typing Your Rails Application: The Easy Way

## Session Format

Talk

## Track

Explain it Like I'm Five

## Abstract

> _A concise, engaging description for the public program. Limited to 600 characters._

Typing an existing Rails application can be seen as a daunting task. But is it really? What if gradual typing could be applied... gradually?

Together, we'll be typing a real-world Rails application running in production. Using Sorbet and Tapioca, we'll show step by step that making your application type safe doesn't have to be scary!

Whether you're just getting started with Ruby on Rails or you're calling the technical shots for your team, come and see how gradual typing can improve your developer experience and make your life easier.

# For Review Committee

## Details

> _Include any pertinent details such as outlines, outcomes or intended audience._

**Format**: This proposal can be accepted as a standalone talk or paired with a workshop where the participants will type the application themselves (see our workshop proposal with the same title). We believe that the best format would be a talk followed by a workshop so we can give the basis in the talk and make the participants practice during the workshop.

**Intended audience**: From beginner to advanced Ruby and Rails developers or technical managers.

**Outlines**:

* Introduction to Gradual Typing
    * How does it differ from "full" typing?
    * Typing an existing, and sometimes big, app that already runs in production
    * Splitting our work into small and easy to review bits
    * Keeping our app working in production at each step of the process
    * Getting benefits without changing our application too much

* Gradual Typing with Sorbet
    * How does it compare to RBS?
    * Why did we choose Sorbet for this demonstration?
    * What if we later want to switch from Sorbet to RBS?
    * What is a RBI file?
    * What is a shim file?

* Tools of the trade
    * `sorbet-static` to statically type check our application
    * `sorbet-runtime` to enable runtime type checking and provide the `T.*` definitions
    * `vscode` to benefit from Sorbet's LSP features
    * `tapioca` to generate the RBIs for our gems and DSLs
    * `rubocop-sorbet` to autocorrect the incompatibilities and enforce styling
    * `spoom` to track our progress

* Typing rubygems.org
    * Basing our demonstration on a concrete, real-world example
    * Overview of the rubygems.org app
    * Anatomy of the app and the parts we'll have to type
    * Description of our approach, `typed: ignored` to `typed: false` to `typed: true` to `typed: strict` and a description of each strictness level

* Getting started with `typed: false`
    * Configuring Sorbet
    * Avoiding `typed: ignore` and typing debt
    * Getting all our files to `typed: false`
    * Autocorrecting incompatibilities with `rubocop-sorbet`
    * Generating the RBI files for our gems with `tapioca`
    * Creating the shims for the missing constants
    * Passing our first type check
    * Enabling type checking in CI
        * Running `sorbet` on pull-requests
        * Keeping gems RBI files up-to-date with `tapioca`
        * Avoiding useless shims with `tapioca`
        * Enforcing `typed: false` with `rubocop-sorbet`
        * Enforcing styling with `rubocop-sorbet`
    * Configuring `sorbet-runtime` to keep our app fast
    * Deploying and monitoring our changes
    * Benefits at this stage
        * Finding parse errors without running the app
        * Spotting undefined constants without testing the app
        * Removing dead code 
        * Performing refactors safely

* Moving files to `typed: true`
    * What should be `typed: true` in our app?
    * Visualizing our progress with `spoom`
    * Generating RBI files for Rails DSLs with `tapioca`
        * Models and validations
        * Controllers and routes
        * Helpers and concerns
        * Jobs and mailers
        * Views and ERBs
        * Tests
        * Rake tasks and migrations
    * Fixing type errors and using escape hatches
        * Disabling typing locally with `T.unsafe`
        * Using loose typing with `T.untyped`
        * Writing shims to unblock ourselves
    * Sharing our shims with the community using `tapioca`
    * Writing our own custom RBI generator for DSL
    * Using `spoom` to automatically bump our files to `typed: true`
    * Avoiding drifts in CI
        * Keeping our RBI files for DSL up-to-date with`tapioca`
        * Enforcing `typed: true` with `rubocop-sorbet` and `spoom`
    * Benefits at this stage
        * Finding unknown methods
        * Unlocking powerful LSP features in `vscode`
        * Making our app evolve safely
        * Bumping gems versions easily
        * Enforcing a better design

* Gradually moving to `typed: strict`
    * What should be `typed: strict` in our app?
    * Writing signatures for our methods
    * Using signatures to express intent and avoid corner cases
    * Benefits at this stage
        * Understanding corner cases
        * Fixing our type errors
        * Generating an evergreen documentation with `yard-sorbet`

* Going further
    * Typing best practices
    * Typing patterns for Rails apps
    * Working across teams

**Outcomes**:
* A better understanding of gradual typing with Sorbet
* A concrete example of how to type a real Rails application
* A presentation of the tools involved in typing with Sorbet
* A gradually typed rugygems.org branch
* An explanation of our findings while typing the app

## Pitch

> _Explain why this talk should be considered and what makes you qualified to speak on the topic._

We're in the era of Gradual Typing for Ruby. While Sorbet was open-sourced in June 2019, typing a Rails app with it didn't get much attention. Then, in December 2020 Ruby 3.0 introduced RBS and typing became a major focus of the release. Furthermore, Matz announced during RailsConf 2021 that tooling improvements would be the cornerstone of upcoming releases. We think that RailsConf 2022 is a timely occasion to cover the topic of typing and how it enables a better developer experience.

The speakers have been leading the typing of a large Rails application and continue driving gradual typing adoption both in their company and in the community. They are contributors to Sorbet and have released a number of open-source tools in the ecosystem. They also contributed to the specification of RBS for Ruby 3.0!

# Speaker Information

## Name

* Alexandre Terrasa
* Ryan Brushett

## Bio

> _Your bio should be short, no longer than 500 characters. It's related to why you're speaking about this topic._

Alexandre has a PhD in computer science about compiling and code documentation. He specializes in typing specifications and implementations. He currently works as a Staff Production Engineer on the Ruby and Rails Infrastructure team at Shopify. He uses his expertise for the adoption of better Ruby tooling and practices including Sorbet and gradual typing.

---

Ryan is an engineering manager on the Ruby Types team at Shopify where he spends his time working on gradual typing of Ruby codebases and building tools to improve the Ruby developer experience.

Some of Ryan's hobbies include playing guitar, taking photos, and petting cats. He is from Newfoundland, Canada.

## Private notes

* Models
    * Validation hooks: before_*
    * Attributes are nilable
    * Associations and relations
    * Typed store

* Examples
    * Flow typing
    * Changing a column type and spotting the required changes

* Resources
    * https://development.shopify.io/engineering/keytech/reference/sorbet/services_db_typed_true
    * https://github.com/Shopify/shopify/pull/306852
