## 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.) That's a lot of hands. 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 us experience Ruby this way. We attend the events. We use the gems. We follow the discussions. And the community itself somehow feels like something happening somewhere else, run by people more experienced, more visible, more important than us. I want to tell you the simplest, strangest thing I've learned about this: **You don't join the Ruby community.** **You are the Ruby community.** That's it. That's the whole talk. Every hand that went up a minute ago? That was the community in motion. The reading, the listening, the using, the mentoring, the showing up. You've been doing this the whole time. You just didn't realize it counted. The rest of what I'm going to say tonight is just me proving it. ### The Pyramid We Imagine Most of us 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 really pyramids, even when they look like one from the outside. You see the speakers and the maintainers because they're visible. What you don't see is the thing actually holding the community together. It isn't a hierarchy. It's a network of participation. Ecosystems survive because of thousands of small acts 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. The conversations are what sustain it. ### The Bridge So how do you cross from *using Ruby* to *being part of the Ruby community*? You participate. 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 stopped only consuming what other people made and started contributing something back, however small. The gem you `bundle install` was written by someone. Somebody else filed the issue that made it better. Somebody else thanked the author. Somebody else wrote the tutorial that helped you understand it. The community isn't *behind* the tool. It *is* every person who chooses to engage with the tool instead of only using it. Participation has a lot of shapes. Asking a question. Answering one. Filing a bug report. Writing a blog post. Saying thank you. Showing up to a meetup. Making a friend. Becoming one. The form doesn't matter much. The choice does. Once you've participated, even once, something shifts. You have skin in the game. You care about the next release because you filed an issue against the last one. You read the RFC because you commented on a draft. You show up to the meetup because last time, you talked to someone there. One act of participation turns the language into a place. Many acts turn the place into a community. ### How I Got Here My name is Andrew. I've been writing Ruby for about ten years. These days I co-host a podcast called Remote Ruby with Chris Oliver and Jason Charnes. If you'd told my junior-developer self that, I would not have believed you. Because when I started, I didn't know a single Rubyist 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'd done something *for* the Ruby community instead of only consuming it. That was the bridge. A few years later I started showing up on more shows, eventually joining Remote Ruby. Each episode was another small act of participation. Some of them turned into friendships. Some stayed acquaintances. Some were one-off conversations I never repeated. All of them counted. The way I got from "I don't know anyone in Ruby" to "I co-host a Ruby podcast" had almost nothing to do with becoming a better engineer. It had everything to do with showing up, one small contribution at a time. For a long time I thought *contributing* meant maintaining gems, contributing to Rails, speaking at conferences. Those are real contributions. They aren't the only ones. The thing I was good at was asking questions. Asking questions out loud, in public, where other Rubyists could hear them, turned out to be a contribution too. That's how I found my community. Not by being the smartest person in the room. By being curious enough to participate before I felt qualified to. ### The First Barrier Is Often Internal If communities are just people connected by a shared tool, why do so many of us still feel like outsiders? Some barriers are real. Geography is real. Money is real. Time is real. Bad experiences are real. But a lot of the barriers between you and that first act of participation 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. And here's the part nobody tells you: most participation isn't loud or visible. It's small. A reply. A question. A thank you. A bug report. The accumulation is what builds a community. When you thank a gem maintainer, you're not just being polite. You're showing up for the work they did. When you ask a question in a Slack channel, you're not just trying to solve a problem. You're adding to the record of how Ruby gets used. When you reply to a Rubyist's post online, you're not just commenting. You're contributing to the conversation that is the community. Most of the lasting relationships in this community started as a comment, a reply, a question, or a thank you. Friendships. Mentorships. Collaborations. Jobs. 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. Something that just 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 just as important: you've added something to the ecosystem instead of only taking from it. That's the first plank of the bridge. And if you've been around Ruby for a while, you have a role here too. You might be the person someone is nervous to talk to. You might be the person who can answer the question they've been afraid to ask. You might be the person whose reply makes the whole community feel real to them. ### 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 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. That matters even more in this moment. And we are 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 a community isn't. An AI can hand you the language. It cannot be the community around it. It cannot file the bug report that fixes the gem you depend on. It cannot run the meetup that introduces you to the maintainer. 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. AI can produce Ruby code. Only we can produce the Ruby community. When 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. Ruby is alive because we are here. And the next person who walks into this ecosystem may stay because somebody in this room chose to show up. ### 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. Remember what I told you at the top: **You don't join the Ruby community.** **You are the Ruby community.** The people sitting next to you right now? They're not the gatekeepers. They're the ones who chose to show up. Just like you did. **We are the Ruby community.**