This is not a technical post. You can check their website to see the technical details. What I want here is to share some of the vibes of Hanami and how I felt working with it.

Make your own batteries

My first feeling while working with Hanami was about not having everything at my fingertips. Knowing it has far fewer batteries included made me hesitate at the beginning, I confess. But I started wondering: did I really need all of those batteries?

I started to think about all those features that were not really needed in any of my personal projects, but I installed them because I liked the idea of having everything set up from early on.

Hanami doesn’t offer that out of the box. It seems to encourage some independence in this regard, and setting up Sidekiq or making custom mailers turned out to be simpler than I expected (but mailers are coming in the next version anyway).

Hanami caught my attention because it tackles another problem.

Moving to a city with good infrastructure

Keeping a codebase organized has always been a huge challenge for me. Even with a solid mental model, my projects tend to bend into more heterodox paths, and suddenly the underlying structure is gone.

That’s especially concerning in MVC frameworks. It’s like they give a very good infrastructure in the downtown area, but anything far away from this idealized matrix becomes an ‘every man for himself’ situation.

Hanami brought a different dynamic to my workflow by establishing the structure beforehand. Need queries? I learned to reach for Relation. Registering a third-party lib? Providers are there. Business logic? Operations. And there are many other built-in solutions guiding the way.

It’s like all the roads have already been made, and now we can build our city in peace, knowing that anywhere we go with our code, we will have a Hanami solution to guide us.

It’s so light

This is the part that empowered me the most. Hanami relies on a component system where pieces can be called anywhere as a dependency. I found myself putting everything together like a Lego set. Check out this example below:

module Bookshelf
  module Operations
    class SendWelcomeEmail
      include Deps[
        "email_client",
        email_renderer: "renderers.welcome_email"
      ]

      def call(name:, email_address:)
        email_client.deliver(
          to: email_address,
          subject: "Welcome!",
          text_body: email_renderer.render_text(name: name),
          html_body: email_renderer.render_html(name: name)
        )
      end
    end
  end
end

This setup gave me a comforting sense of control. Instead of a black box that I had to tiptoe around, the whole system was right there in my hands, allowing me to experiment without fear of breaking hidden magic.

It reminds me a lot of the feeling when I started to like Linux more than Windows.

Hanami deserves a chance

Disorganization has always been my biggest enemy in programming. Facing a messy codebase drains my motivation easily. Over time, I learned to accept that pressure inevitably compromises my initial intention of keeping things tidy.

Discovering Hanami felt like getting a tool designed to help get things right this time around. It faces a tough crowd because short-term gains are tempting, and other frameworks excel at that.

But I feel like Hanami is here for the long game. It carries the energy of passionate development, currently maintained by someone who dances “Viva la vida loca” in a talk about Hanami.

Not only that, it is the only framework I know that places right on its homepage, with great prominence, that its goal is to build a diverse and inclusive community. And many people miss that in the Ruby environment.

I will do my part by sharing the cool things I find. I’m not someone with deep technical knowledge, but I have good taste. And Hanami is for those who appreciate fabulous code 💅