## We Are the Ruby Community ### Opening (Hook) ==Start from large to small contributions, ending with attended a conference so everyone has their hand raised. This way people don't feel left out. This means changes to some sentences below need to happen. Also, the list is too big.== Raise your hand if you’ve ever: - Spoke at a conference - Created an open source project/gem - Contributed to an OSS project/Ruby for good - Mentored someone - Written a blog post - read a gem’s documentation - followed someone in the Ruby ecosystem online - Listened to a Ruby podcast (like Remote Ruby) - used Ruby for work - used Ruby for fun - Attended a Ruby conference Now keep your hand up if you’ve ever felt like you still weren’t really part of the Ruby community. ==(see highlight above) Should this be about how we all feel like we don't belong or how we all already do?== Look around the room for a second. (Pause. Let people look around the room.) A lot of developers experience Ruby this way. We attend the events. We use the gems. We follow the discussions. ==end review section== But the community itself can feel like something happening somewhere else… run by people who are more experienced, more visible, or more important than us. But 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. ==Statement below is not a great transition== At one point in my career, I actually thought the Ruby community might disappear. I’ll come back to that in a bit. ### What People Think a Community Is Most developers imagine a technical community as a pyramid. I used to picture it this way myself. At the top were the people who seemed like the “real” community: - Ruby core team - gem authors - conference speakers - maintainers - well-known names on GitHub or Twitter And then there was everyone else. The people writing Ruby at work. Reading blog posts. Listening to podcasts. Watching talks. I didn’t think I was outside of Ruby exactly. I just thought I was adjacent to the community. Close enough to see it. Not close enough to claim it. ==ew. We can improve this last sentence== And I think a lot of Ruby developers feel that way. Like the community is a room full of important people, and we’re standing near the doorway hoping nobody notices we don’t belong there. ==banger alert== ~~But communities aren’t pyramids.~~ ~~They’re ecosystems.~~ > Communities might look like pyramids from the outside. You see the speakers. The maintainers. The well-known names. But if you zoom in, communities behave more like ecosystems. > [!error] Goal: Reframe community from hierarchy to ecosystem > > - Saying “communities aren’t pyramids” is rhetorically strong but logically fragile. Many developers know communities do have influence hierarchies (maintainers, core teams, speakers). > - If a listener mentally rejects the statement, they may dismiss the ecosystem framing before you reach the real point: that participation exists at every level. ==The statement above feels repetitive.== And ecosystems survive because of thousands of small conversations happening every day. - someone asking a question - someone answering it - someone writing a blog post - someone fixing a typo in documentation - someone organizing a meetup - someone organizing a conference ===repetitive with above=== - someone simply showing up The visible parts of the ecosystem get attention. But they are not what sustains it. ==Another banger== The conversations are. ### Finding the Community When I first started writing Ruby, I didn’t know anyone else who used it outside of the 3 people I shared an office with. None of the local meetups talked about Ruby. None of my classmates used Ruby. It felt like the Ruby community didn’t exist where I lived. But I kept hearing about it. I was a big podcast listener, and every Ruby podcast talked about how amazing the Ruby community was. And I remember thinking: “Where is this magical community everyone keeps talking about? Because I’ve never seen it.” ==Same sentiment Jamie said during Portland conf== So I decided to go find it. There was a podcast called *The Ruby Testing Podcast* hosted by Jason Swett. One day I messaged him and basically said: “Hey… can I just come ask you questions about testing from a junior perspective?” (Pause.) And to my surprise… he said yes. So I showed up and recorded my first podcast episode. When the episode released, I remember feeling like I was finally part of the Ruby community. For a long time I thought contributing meant things like: - maintaining gems - contributing to Rails - speaking at conferences And those are amazing contributions. But they weren’t the thing I was best at. What I was good at was asking questions. And it turns out asking good questions is actually a pretty valuable skill in a community. ~~Communities aren’t built by experts sharing knowledge.~~ > Communities aren’t built only by experts sharing knowledge. They’re built by conversations. Someone asking a question. Someone answering it. > [!error] Goal: Break down psychological barriers > - The line is memorable but logically overstated. Developers know experts clearly contribute heavily. > - If the audience mentally disagrees, it weakens the credibility of the message encouraging beginners to participate. ~~Beginners~~ ==New Rubyists== often ask the best questions, because they notice the confusing parts everyone else has forgotten. They’re built by beginners asking questions. ==Weird transition== Seven years later I’ve been on hundreds of podcast episodes across multiple Ruby shows. And that’s how I found my community. Not by being the smartest person in the room. Just by being curious enough to participate. ### Invisible Barriers If communities are ecosystems, why do so many developers still feel like outsiders? Because the barriers are usually psychological, not technical. ==Should be more leading than prescriptive== Developers tell themselves things like: - “I’m not experienced enough.” - “I don’t know Ruby well enough yet.” - “Someone else probably already knows this.” - “My question might be dumb.” - "People will look at me differently (or imposter syndrome relation or cut this) if I ask this" These thoughts are incredibly common. They appear in beginners who just joined a Rails team. They appear in experienced developers who have been writing Ruby for ten years but rarely participate publicly. They even appear in veterans who used to be active but gradually stepped away. The irony is that the Ruby community’s culture was built specifically to counter these fears. This idea goes all the way back to Ruby’s creator, Matz. He said Ruby was designed 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 supporting each other. Just like you. ==Line above added to keep audience engaged== ### Consuming Vs Participating Many developers consume the Ruby community without realizing they could participate in it. Consuming looks like: - reading blog posts - watching conference talks - using gems - browsing GitHub repositories Participation looks almost the same. It just adds one small ingredient: interaction. ==I like this framing== Participation often starts with ~~extremely~~ small actions: - asking a thoughtful question - thanking someone who helped you ==(or thanking a maintainer?)== - writing down something you learned - reporting a bug - sharing a solution You don’t need authority. You just need interaction. ==banger== The moment you contribute something back—even something small—you are participating. Participation is what creates community. ==weak conclusion== ### Everyday Actions That Build the Ruby Ecosystem ==This section could be combined with the section above, potentially. It feels repetitive and just restarting.== When people think about contributing to a technical community, they often imagine something big. Writing a long blog post. Maintaining a gem. Giving a conference talk. But the truth is that most community participation happens through very small actions. Things like: - asking a question in a Slack or Discord - answering someone else’s question - opening a GitHub issue with a clear reproduction - adding a helpful comment to an issue - adding a reaction to an issue so maintainers know other people are affected - improving a confusing sentence in documentation - sharing a short code snippet that helped you - reposting something useful you saw online - sharing a quick Rails tip you learned today You don’t need a full blog post. Sometimes the most valuable thing you can do is just write down the one small thing you learned today. And beginners often ask the best questions, because they notice the confusing parts everyone else has forgotten. ==Definite repetition. Is this useful for emphasis or just repetitive.== Many of the most useful GitHub issues are simply a clear reproduction and a few lines explaining what went wrong. Participation also doesn’t have to happen online. Sometimes it’s as simple as showing up. If you want to find Ruby developers near you, check Meetup.com. And 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 literally be five developers in a coffee shop talking about Ruby. Sometimes it’s even smaller than that. It might just be grabbing coffee with another developer in your area. Or 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 small conversations. ==I really like this framing, but this could be reworded.== If you want a first step, here’s one. Tonight, go to a gem you use on GitHub and open an issue that says: “Hey, this part of the documentation confused me.” ==Improve example. Maybe send email to maintainer thanking them instead? == That counts. You just improved the Ruby ecosystem. And experienced developers have a role here too. Sometimes the most valuable contribution you can make is explaining something you’ve known for ten years to someone seeing it for the first time. One more thing that matters. Don’t wait for things to be perfect before sharing them. Perfect knowledge never ships. ==Useful but feels like personal bias overemphasizing this minor point== Most useful knowledge looks more like: “Hey, I ran into this weird Rails thing today and here’s what fixed it.” If something confused you today, chances are it confused someone else yesterday and will confuse someone tomorrow. A lot of Ruby knowledge spreads through conversations, not just code. The Ruby ecosystem isn’t built by a few big contributions. It’s built by thousands of small ~~conversations~~ ==ones==. ### Closing Earlier I mentioned that at one point I thought the Ruby community might disappear. ==is the callback necessary or could this story start here== When I first started writing Ruby on Rails, a lot of well-known community members were moving on to other things. Some were exploring React. Some were getting excited about Elixir. And I remember feeling a little scared. I wondered what would happen to Ruby. Who would fill the void ~~when~~ those people left? How would I keep writing the language I loved if the community slowly disappeared? 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 ~~really~~ replaced. They inspired other people to continue the work. And one day I realized something ~~surprising~~. Without even trying… I had helped fill part of that void too. Not by doing anything extraordinary. Just by showing up. That’s how communities survive. Languages survive because of the communities around them. ==weak argument. I feel like we could do something nice here to wrap the community and language together as symbiotic == And in an era where AI can generate code instantly, the human side of software matters more than ever. ==could definitely say more here== The thing that keeps Ruby alive isn’t just the language. It’s the people. ==banger== 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. ==banger== **We are the Ruby community.**