r/ruby

This post introduces* a new profiler for Rails app, require-profiler, to get insights on what's happening during your Rails app's boot. Why does it matter? Well, check out the post to learn about that as well as some real-world examples of when cutting the boot time made difference.

* To be precise, the profiler has been introduced earlier this year at RubyKaigi but it grew much stronger since then.

Hi Reddit. This isn't specifically a Ruby or Rails post, but it's about something anyone maintaining a mature Rails application will recognize.

Code tells you what happens without telling you why anybody wanted it. We've always filled that gap by reading the code, guessing the intent, and asking somebody when the guess felt wrong.

AI coding agents do the same thing, except they can make a great many reasonable guesses before anybody notices one was wrong. The code still works. The tests still pass. The guess becomes one more pattern in the application, which makes it look even more intentional to the next person or agent.

I've spent a couple of decades living with the consequences of my own good ideas, so I wrote about why this worries me. The post connects agentic coding to Peter Naur, Tony Hoare, XP, software factories, and the old-fashioned responsibility to say no to code that works but is too difficult to understand.

It also argues for using faster agents to take smaller steps. More research, more feedback, and less archaeology at the end of a giant pull request.

https://blowmage.com/2026/08/18/everybody-guesses/

I am a ROR developer for 3 years now, need to submit a good Ruby/Rails related talk.

I know I should decide my topic based on the work I do but need suggestions from community what topics talks are good and knowledgeable.

Do let me know if you know anything intresting around Ruby or Rails.

Thanks

A deep-dive into introducing fairness to background jobs in Rails application (that’s when you have a mammoth customer occupying the queue and blocking smaller ones’ jobs). Strategies and tools explored (such as https://github.com/baygeldin/sidekiq-fairplay, https://github.com/Envek/sidekiq-fair\_tenant, https://github.com/palkan/faqueue).

Hey everyone,
I'm looking to learn programming purely as a hobby (definitely not looking for a career change). I've tried out a bunch of different languages, including Python, which honestly didn't really click for me, but the two that I found super cool and really enjoyed are Ruby and Rust.
I'm well aware of how completely different they are. One is high-level and expressive, the other is system-level and super performant. Even with those differences, I'm equally interested in both and can't decide where to start.
Long term, I'd love to build a mix of side projects just for fun, like:

A simple Web App / REST API

A real-time chat application

Maybe some Desktop Apps down the road

Since my main goal is just to have fun, learn, and build cool stuff, which one would you recommend starting with?
Appreciate any thoughts or advice!

I wanted to be able to debug a ruby script I'm writing that presents a menu and gets input. I jumped through various hoops but I think I have everything properly installed now - rbenv, ruby, bundle, and vscode. But output is still not appearing in either the debug console or the terminal.

Googling the problem, it looks like stdio in the target script is not allowed in vscode/ruby-lsp debugging. Do I understand correctly? If so, that looks like a major limitation and makes it unusable for my needs.

I am writing a reasonably simple terminal script in ruby and work would go faster if I could debug. Is there a combination of things that would allow me to debug a simple script that uses stdin/stdout. I'm on a mac.

Hey everyone!
I have zero programming experience and I’m looking to pick up coding as a hobby. My main goal right now is to understand how the web works under the hood, specifically building and consuming APIs (like fetching data from public APIs and working with JSON).
I’ve been reading a lot about Ruby (and Rails) recently, and its syntax looks very clean and human-readable. But I have a few honest questions before I dive in:

Is Ruby beginner-friendly for total newbies?
Can I actually grasp core concepts like HTTP requests, REST APIs, and database connections using Ruby without getting overwhelmed?

How is the Ruby ecosystem doing?
Is it still active and well-maintained for beginners? Or is it mostly supported by legacy systems?

Ruby vs. Python for a hobbyist:
Is Python just the objectively better choice because of its massive popularity, or does Ruby offer a smoother/more enjoyable learning experience for web-related stuff?

My long-term goal is just to enjoy building cool side projects, but I want a solid, fun starting point.
Would love to hear your thoughts, especially from anyone who started learning with Ruby recently! Thanks!

Edit: I'm not looking to get a job or change careers with this! Programming is purely a hobby for me. I just want to build cool personal projects in my free time and have fun along the way.

I'm really happy with this version. It feels like CSS Zero has finally reached the point I always wanted it to be.

Honestly, this could be the last major version for a long, long time.

Small, simple, modern CSS — without unnecessary opinions.

Showcase: https://csszero.lazaronixon.com
Repo: https://github.com/lazaronixon/css-zero

France has a decent number of local Ruby meetups (Paris, Lyon, Toulouse, Nantes, Lille, Marseille all have active groups), but there wasn't really a place to hang out *between* meetups, no shared Discord, no central spot to ask a quick question or hear about what's happening in other cities.

I put together **France.rb** to fill that gap: help channels, a channel per city that relays local meetup events, and a freelance/jobs section since a good chunk of the French Ruby scene works independently. It's brand new (launched this week, still tiny), and it's mainly aimed at French speakers, so if you don't speak French it's probably not that useful to you day-to-day, but Rubyists from anywhere are welcome to drop in.

Not trying to compete with the official Ruby Discord linked on ruby-lang.org this is just something more specific to the French scene, meant to complement it.

https://discord.gg/tEbywwkYY

Happy to answer anything in the comments, and if you know a French-speaking Rubyist who might be into it, feel free to pass it along.

I maintain RubyLLM, and one of its dependencies has been quietly useful to people who have nothing to do with LLMs. It was always a clean, general purpose JSON Schema DSL. It was just called RubyLLM::Schema, so unless you already used RubyLLM you'd never find it.

It's now grown to fully cover the latest JSON Schema spec, Draft 2020-12, with no dependencies at all. Which earned it its own name: Schematist.

class Order < Schematist::Schema
  string :kind, enum: %w[personal business]

  given kind: "business" do
    object :tax_details do
      string :vat_number
    end
  end
end

Order.new.to_json_schema
# => { "$schema" => "https://json-schema.org/draft/2020-12/schema", "title" => "Order",
#      "type" => "object", "if" => {...}, "then" => {...}, ... }

Eight lines of Ruby, 47 lines of JSON Schema.

What 1.x brings:

• It emits actual JSON Schema. to_json_schema used to return {name:, description:, schema:, strict:}, which is OpenAI's response_format wrapper with the real schema buried inside it. Now you get a Draft 2020-12 document with string keys that any validator will take.
• Full Draft 2020-12 coverage. Composition, unevaluated properties and items, patternProperties, propertyNames, prefixItems and open ended tuples, contains, annotations, content encoding, the core $ keywords, and if/then/else branches that hold any schema rather than a fixed list of validations.
• A schema doesn't have to be an object. A type with a name declares a property, without a name it declares what the schema itself is. So a root, or a define, can be an array, a union, or a bare $ref.
• Zero runtime dependencies.
• Values can be procs, resolved when the document is rendered, so one schema class produces a different document per instance. Useful when an enum comes out of the database.

Existing users: there's a final ruby_llm-schema release that depends on Schematist and aliases the old constants, so RubyLLM::Schema keeps resolving while you migrate. to_json_schema changing shape is the one thing to watch, and the README has the migration.

All of this is part of my concerted effort to make Ruby the best language to build with LLMs.

Write-up: https://paolino.me/schematist/

Repo: https://github.com/crmne/schematist