## We Are the Ruby Community ### Opening Raise your hand if you've ever: - Spoken at a Ruby conference - Created or maintained a Ruby gem - Contributed to an open source Ruby project - Mentored another Rubyist - Written a blog post about Ruby - Listened to a Ruby podcast - Followed a Ruby developer online - Read a gem's documentation - Used Ruby at work - Used Ruby for fun - Attended a Ruby conference Look around. (Pause.) Every hand in this room is up. Now keep your hand up if you've ever felt like you still weren't really part of the Ruby community. (Pause.) A lot of developers experience Ruby this way. We attend the events. We use the gems. We follow the discussions. But the community itself can feel like something happening somewhere else — run by people more experienced, more visible, more important than us. Here's the strange thing about communities. They don't actually work that way. This talk is about one simple idea: **We are the Ruby community.** Not someday. Not after publishing a gem. Not after speaking at a conference. Right now. And if you raised your hand a moment ago, you're already part of it. You just might not have noticed yet. At one point in my career, I actually thought the Ruby community might disappear. I'll come back to that in a bit. ### The Pyramid We Imagine Most developers picture a technical community as a pyramid. I used to picture it the same way. At the top: the Ruby core team, gem authors, conference speakers, the well-known names on GitHub. Everyone else: writing Ruby at work, reading blog posts, listening to podcasts, watching talks. I didn't think I was outside of Ruby. I just felt adjacent to it — standing near the doorway, hoping nobody noticed I didn't belong inside. A lot of Rubyists feel that way. But communities aren't pyramids. They aren't even circles you're either inside or outside of. There's no wall. A community is a directed graph of relationships. (Pause.) That sounds like jargon. Here's what it means. Belonging isn't a fact. It's a perception. And the perception can fail in both directions. You can feel like you're outside while other people already see you as inside. You can think someone isn't part of the community while they feel like they are. My CTO, Jamie Lawrence, once told me about running a tiny Ruby meetup in Cork — three or four people in a hotel lobby once a month. He didn't consider himself part of the Ruby community. The "real" community, to him, was the people flying to RubyConf and RailsConf. And he assumed nobody at those conferences was thinking about three guys in a hotel lobby in Ireland. Both of those things were probably true. And both of them were the community. We wait for someone to confirm we belong. The people who could confirm it don't even know we exist yet. Meanwhile, somebody on the other end is waiting for *us* to confirm *they* belong. Ecosystems survive because of thousands of small conversations every day: - someone asking a question - someone answering it - someone fixing a typo in the docs - someone helping a newcomer at a meetup - someone simply showing up The visible parts of the ecosystem get the attention. But they are not what sustains it. The conversations are. ### The Bridge So if we're already part of it, how do you cross from *feeling adjacent* to *feeling part of it*? You make a friend who uses Ruby too. That's the whole bridge. It sounds almost too simple. But every community I've ever belonged to came down to that single move — I went from interacting with a tool to interacting with a person who cared about the same tool. The gem you `bundle install` was written by someone. The podcast you listened to on your commute was recorded by someone. The Stack Overflow answer that saved your afternoon was typed by someone. The community isn't *behind* the tool. It *is* the people behind the tool. And once you have one friend in that ecosystem, something changes. You have skin in the game. You care about the next release because your friend works on it. You read the RFC because your friend wrote it. You show up to the meetup because your friend will be there. One friend turns the language into a place. Many friends turn the place into a community. ### Finding That First Friend When I started writing Ruby, I didn't know anyone else who used it outside of three people I shared an office with. None of the local meetups talked about Ruby. None of my classmates used it. It felt like the Ruby community didn't exist where I lived. But every podcast I listened to talked about how amazing the Ruby community was. And I remember thinking: "Where is this magical community everyone keeps talking about? I've never seen it." So I decided to go find it. There was a podcast called *The Ruby Testing Podcast*, hosted by Jason Swett. One day I sent him a message that basically said: "Hey… can I just come ask you questions about testing from a junior perspective?" (Pause.) To my surprise, he said yes. I recorded my first podcast episode. When the episode released, something shifted. It wasn't that I'd suddenly become important. It was that I was suddenly *known by one person who cared about Ruby*. That was the bridge. For a long time I thought contributing meant maintaining gems, contributing to Rails, speaking at conferences. Those are real contributions. But the thing I was good at was asking questions. And asking good questions turned out to be how I made my first Ruby friends. Seven years later, I've recorded hundreds of podcast episodes across multiple Ruby shows. That's how I found my community. Not by being the smartest person in the room. Just by being curious enough to reach out to one person. ### The Barriers Are Inside Your Head If communities are just people connected by a shared tool, why do so many developers still feel like outsiders? Because most of the barriers between you and that first friend are psychological. You've probably thought some version of these: - "I'm not experienced enough." - "I don't know Ruby well enough yet." - "Someone else probably already knows this." - "My question might be dumb." - "What if they don't reply?" These thoughts appear in beginners who just joined a Rails team. They appear in developers who've written Ruby for ten years but rarely participate publicly. They even appear in veterans who used to be active and gradually stepped away. The irony is that Ruby's culture was built specifically to dissolve these fears. Matz designed Ruby to make programmers happy. That philosophy didn't just shape the language. It shaped the culture around it — kindness, curiosity, mentorship, sharing knowledge. That culture wasn't built only by famous maintainers. It was built by thousands of everyday developers being generous to each other, one conversation at a time. Just like you. ### Consuming, Participating, Connecting Most of us consume the Ruby community without realizing we could participate in it. Consuming looks like: - reading blog posts - watching conference talks - using gems - browsing GitHub repositories Participating looks almost the same. It just adds one ingredient: interaction. - asking a question instead of only reading answers - thanking a maintainer instead of only `bundle install`-ing their gem - replying to a post instead of only scrolling past it - showing up to a meetup instead of only seeing the announcement You don't need authority. You just need interaction. Here's the part nobody tells you: most participation isn't really about the content. It's about starting a conversation that might turn into a friendship. When you thank a gem maintainer, you're not just being polite. You're introducing yourself. When you ask a question in a Slack channel, you're not just trying to solve a problem. You're creating an opening for someone to reply. When you reply to a Rubyist's post online, you're not just commenting. You're making yourself known. Most of the lasting friendships in this community started as a comment, a reply, a question, or a thank you. If you want a first step, here's one: Tonight, find a gem you've used this year. Send the maintainer a short message — an email, a GitHub thank-you, a post on whatever platform they're on — that says: "Hey, I use your gem at work. It made my life easier. Thank you." That's it. That counts. You haven't fixed a bug. You haven't shipped a PR. You've done something more important — you've started a conversation with another Rubyist. That's the first plank of the bridge. ### Showing Up In Person Participation doesn't have to happen online. Sometimes it's as simple as showing up. If you want to find Rubyists near you, check Meetup.com. If there isn't a Ruby meetup in your area, you can create one. You don't need to organize a big event. A meetup can be five developers in a coffee shop talking about Rails. Sometimes it's smaller than that. It might be grabbing coffee with one other developer. Meeting one other Rubyist on Zoom once a month and talking about what you're building. Communities don't start with big events. They start with two people deciding to be in the same room. ### Why This Matters Right Now Earlier I mentioned that at one point I thought the Ruby community might disappear. When I first started writing Ruby on Rails, a lot of well-known community members were moving on. Some to React. Some to Elixir. I remember being a little scared. I wondered who would fill the void. But communities change. People move on. Interests shift. That's normal. And something interesting happened. New people showed up. The developers who moved on weren't replaced — they inspired other people to continue the work. Without even trying, I had helped fill part of that void too. Not by doing anything extraordinary. Just by showing up and making friends along the way. That's how communities survive. And we're in a strange moment for software right now. AI can generate Ruby code instantly. It can explain syntax, write tests, refactor a controller, recommend a gem — in seconds. Tools are getting cheaper. Knowledge is getting cheaper. But friendship isn't. An AI can hand you the language. It cannot hand you a community. It cannot introduce you to the maintainer of your favorite gem. It cannot sit next to you at dinner after a conference talk. It cannot text you "did you see the new Rails release?" the moment it drops. In an era where the *code* is increasingly automated, the *people* are what make a language worth using. Languages and communities are symbiotic. The language gives the community something to gather around. The community keeps the language alive — by teaching it, defending it, evolving it, and making it feel like home. The thing that keeps Ruby alive isn't just the language. It's the people. ### Closing So the next time you find yourself thinking: "I'm not really part of the Ruby community yet." Look around this room. (Pause.) The Ruby community isn't somewhere else. It's right here. **We are the Ruby community.**