Domain Modeling in Rails

A four-week live cohort course over Zoom in April 2024

Join a small group of software developers (of all experience levels) to grow & sharpen your domain modeling skills, by learning and practicing "Riffing on Rails." Learn how to define & scope design challenges, explore domain solutions on your own and in collaboration, and present & communicate your design concepts to others.

---

“Putting effort into … the design of your software improves the stamina of your project, allowing you to go faster for longer." — Martin Fowler

---

Riffing your way to better designs

Whether you're planning an entire greenfield app or just a single new feature, the high-level design choices you make will likely have a dramatic impact both on the implementation details, and on the quality and maintainability of your software system over the long term.

What's the best way to uncover unknowns, explore possibilities, and refine your ideas without spinning your wheels on minor details, getting stuck in indecision, and settling too early for mediocre solutions?

While typical approaches might be sketching relationships and flows on paper, reaching for Entity Relationship Diagrams, or diving straight into full implementation, there's another approach we call riffing.

Riffing is a simple technique for writing nearly-executable code in a single scratch file, using ordinary Rails classes and methods. The trick is that, by staying low-fidelity and temporarily ignoring completeness and correctness, you can focus on the high-level design by exploring names, relationships, interfaces, and control flows.

Riffing is to development what wireframing is to UI design. It's a fast, low-fidelity design technique for exploring, validating, and communicating design concepts within a tight feedback loop.

For example, how might you build a timeline of items that can be favorited by a user?

class User
  belongs_to :timeline
end

class User::Timeline
  has_many :items
end

class User::Timeline::Item
  belongs_to :timeline
end

class User::TimelinesController
  def show
    @items = Current.user.timeline.items.order(:created_at)
  end
end

# app/views/user/timelines/show.html.erb
@items.each do |item|
  if Current.user.favorite?(item)
    button_to unfavorite_item_path(item), method: :delete
  else
    button_to favorite_item_path(item)
  end
end

In this cohort course, you will learn and practice the riffing technique, both on your own and in collaboration with others, so that you can develop and refine your domain modeling and system design skills.

This course is for…

• Junior and mid-level developers who want to be able to shape and ship features well on their own — and in the future, architect systems
• Senior developers who want more domain modeling practice and are interested in learning the riffing technique
• First-time bootstrappers who need practice on basic domain modeling concepts to improve early-stage decisions in their apps
• Second-time founders who know the importance of upfront design for improving longterm project outcomes
• Experienced developers who want to improve their ability to collaborate with and communicate design concepts to others

This course will help you…

• Spec features and systems faster
• Improve efficiency through tighter feedback loops
• Collaborate more effectively with team members and stakeholders
• Develop a stronger divergent thinking phase
• Organize and communicate system designs
• Improve team alignment, understanding and shared ownership
• Remove friction from the ideation process
• Improvise and "yes, and" when designing with others

Sessions

Course sessions will be held for 90 minutes over Zoom, every Thursday in April at 6pm CEST (12pm EDT). Each session will include direct teaching time, discussion, and practice exercises. Expect 40-60 minutes of homework between each session.

🎷 Session 1: Introduction to Riffing

April 4 at 6pm CEST (12pm EDT)

We will make introductions and establish ground rules for our learning community, so that everyone can safely and comfortably share their ideas and questions and practice the techniques. We will introduce and demonstrate riffing, discuss how and why design matters, look at various ways to approach domain modeling, and provide guidance for how to craft modeling prompts for design exploration.

🕺 Session 2: Riffing Solo

April 11 at 6pm CEST (12pm EDT)

We will discuss modeling prompts, give guidance for solo riffing sessions, create space to practice riffing, share designs and discuss the practice rounds. At the end of the session, you'll have the mechanics down and have the confidence to try riffing on your own.

👥 Session 3: Riffing Together

April 18 at 6pm CEST (12pm EDT)

We will introduce the rules and process for design exploration and ideation in collaboration with others. We will create space for all participants to practice riffing in pairs, with time to discuss and reflect on the outcomes.

📔 Session 4: Communicating Your Designs

April 25 at 6pm CET (12pm EDT)

We will demonstrate and discuss how to present and communicate your design concepts and riffing artifacts to other team members and stakeholders. We will look at how to take your low-fidelity artifacts and move them towards higher-fidelity versions: first make it runnable and then make it deployable. We will also suggest how you could introduce riffing to the rest of your team.

Expectations

We don't care about experience level or how many years a participant has done Ruby/Rails. We're here to try something new and learn together, not to impress each other.

To give us all a safer environment to let our gentle, creative side out more, we request that course participants be on mic and video — we also won't be recording sessions for this reason.

Participants can expect 40-60 minutes of homework between sessions.

Your Instructors

Kasper Timm Hansen

Kasper is a former Rails core team member, who's been working in Rails for over a decade. These days he does consulting with a focus on small-to-medium shops. He's also involved in many different gems, that take Rails further to help increase code clarity.

Jeremy Smith

Jeremy is a product-focused Rails developer running HYBRD, a one-person web studio. He has been working in Rails for the past 15 years. He co-hosts the IndieRails podcast and is a former organizer for the Blue Ridge Ruby conference.

Frequently Asked Questions

What does "riffing" mean?

"Riffing" is our name for the technique of sketching domain model concepts by writing low-fidelity Rails code within a single text file.

Why not just use ERDs?

Entity Relationship Diagrams can certainly be helpful, but writing low-fidelity code requires fewer tools, can be more natural for developers, is easy to share and collaborate on, and helps clarify how a design will actually be used.

Is this only for Rails developers?

This course will be most beneficial to Rails developers, but the riffing technique could certainly be used in other languages and frameworks. A general understanding of Rails is assumed.

Will the sessions be recorded?

We will not be recording our video sessions. We intend for a high level of group participation, and we want to remove pressure for participants.

How do I get my boss on board?

Since this is all about learning, you can use your development budget. Offer to present the experience to your team.

Do you offer private training for teams?

If you'd like private sessions just for your team, we may offer that soon. Reach out to Kasper on hey@kaspth.com to talk more. We can focus solely on your existing or coming domain model with your team and teach you riffing very deliberately.

Will you offer this again?

It's certainly possible, but we don't know yet.