49 Days of Ruby: Day 41 -- Web Frameworks: Hanami
Tags: ruby
Published: 2021-05-07 04:38:21

---
title: 49 Days of Ruby: Day 41 -- Web Frameworks: Hanami
published: true
description: Join us on a 49 day learning journey through Ruby!
series: 49 Days of Ruby
tags: #ruby
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/9m73qaetuse3nm3y3it8.png
---

**Welcome to day 41 of the 49 Days of Ruby! 🎉**

Yesterday, we began our several-day journey taking brief looks at some of the popular Ruby web frameworks. We started by examining Sinatra, and today, we are going to explore Hanami.

[Hanami](https://hanamirb.org/) is a fully-featured web application. It is built on the MVC approach, which stands for: *Models, Views and Controllers*. When we look at Ruby on Rails tomorrow, we will see another example of MVC.

## What is MVC?

The MVC approach is a method to organizing the work of your web application into its distinct categories. It gives you the chance to both mentally organize the application, which can be helpful as it grows in complexity, and also literally organize where the growing amount of files will go.

Let's break it down.

A **model** is a representation of data objects in your application. It controls the logic, and rules for managing that data. For example, if you have a user table in your database, you would want a `User` model to manage that data object.

A **view** is the presentation layer of your application. It is what visitors interact with.

A **controller** manages the flow between inputs, for example, user input, and models and views.

MVC is an incredibly prevalent form of web development design. You will find the pattern repeated across programming language communities.

How does Hanami do MVC?

## MVC in Hanami

Hanami strives to have each part of the code keep to doing only its part as much as possible. Each class, and by extension each file, should stick to a single responsibility.

The following examples come directly from the [Hanami Getting Started Guide](https://guides.hanamirb.org/architecture/overview/).

Models in Hanami will live inside the `lib` folder of your app, just like how the main part of your code in a Ruby gem would live inside `lib`. Here is an example with a model called `Bookshelf`:

```bash
lib
├── bookshelf
│   ├── entities
│   ├── mailers
│   │   └── templates
│   └── repositories
└── bookshelf.rb
```

The `entities` folder is where the model code would go, and the `repositories` folder is where the logic in interacting with the actual database table would go.

Views in Hanami live inside an `apps` folder. The default subfolder is called `web`, but you could have any number of distinct web view structures under different sub-folders.

This is an example file structure for the `apps/web` folder:

```bash
apps/web
├── application.rb
├── assets
│   ├── favicon.ico
│   ├── images
│   ├── javascripts
│   └── stylesheets
├── config
│   └── routes.rb
├── controllers
├── templates
│   └── application.html.erb
└── views
    └── application_layout.rb
```

As you see above, there is an `application.rb` file where all the settings for the app go. The *controllers* go inside the `controllers` folder, and the *views* go inside the `views` folder. There is also a `config/routes.rb` to delineate the different web routes a user might access the app with, and which controller action they correspond to. 

Tomorrow, we will see how MVC looks like with Ruby on Rails, and you will notice how different the structure is.

For the rest of today, try to build your first Hanami web app by following along with the [Get Started Guide](https://guides.hanamirb.org/introduction/getting-started/)!

**Come back tomorrow for the next installment of 49 Days of Ruby! You can join the conversation on Twitter with the hashtag [#49daysofruby](https://twitter.com/hashtag/49daysofruby).**