DEV Community: Ilya N. Zykin

How Makefile Helps Rails Developers

Ilya N. Zykin — Wed, 08 Oct 2025 07:53:15 +0000

Introduction

Several years ago, I needed a quick playground for launching Rails applications for new projects and experiments. I also create video lectures and masterclasses on Rails, and I needed a project where my program attendees could practice their skills.

This is how the RailsStart project was created, which allows launching Rails applications quickly, almost instantly.

The main goal of the project - to enable running Rails on any operating system with literally one command.

In this article, I will tell you about the importance of Makefile for implementing my project. Its architecture is based on the elegant use of Makefile - a tool that transforms complex Docker and Rails commands into simple and understandable calls.

What are Make and Makefile?

Make is a build automation utility that manages the compilation and build process of software. It uses a file called Makefile, which describes the rules and dependencies for building a project.

Makefile is a text file containing a set of instructions for the Make utility.

Makefile is commonly used in C/C++ projects for compilation, in system administration for task automation, in DevOps for deployment management, and in various projects for standardizing development commands.

In my project, Make and Makefile are of great importance. These tools allow me to automate project setup and Rails application launch.

Thanks to the simplicity of Make, launching a Rails application in my project is done simply, elegantly, and with literally one command.

What do you need to run Rails Start?

To run Rails Start, you need only three tools familiar to any developer:

Git - to get the project from GitHub
Make - to run the automatic installation process
Docker - to run the application in a container

If these tools are available on your operating system, you can consider that the Rails application will be installed in less than 5 minutes.

Why do I use Make instead of Ruby scripts?

The first version of the project relied on automation and launch scripts based on Ruby technologies.

However, to make the process universal for host machines where Ruby might not be installed, I switched to using the popular Make, which can be used both on the host machine and in a container.

Advantages of Make over Ruby scripts:

Universality - Make is available on virtually all Unix systems
Independence - does not require Ruby installation on the host system
Simplicity - clear syntax for command automation
Standardness - a familiar tool for developers

Two-Level `Makefiles` Architecture

The key feature of RailsStart lies in the two-level Makefiles system:

The RailsStart project uses 2 levels of Makefiles. One level is designed for use at the host system level (the computer you work on), the second level of Makefiles is designed for use inside Docker containers.

I try to adhere to unified and consistent command names so that identical commands can be run at different levels using approximately identical Make commands.

1. Host Level (Project)

Location: /Makefiles/

This level is responsible for managing Docker containers and orchestrating the entire project. Host-level commands automatically delegate execution to the appropriate containers, providing a uniform interface:

# Simple launch of the entire project
make rails-start

# Container management
make start    # Start containers
make stop     # Stop containers
make status   # Container status

# Delegating Rails commands to container
make rails-console     # Open Rails console
make rails-db-migrate  # Run migrations
make rails-server      # Start Rails server

Main functions:

Docker Compose management
Project environment setup
Command delegation to containers
File structure organization
Unified interface for all operations

2. Container Level

Location: /__RailsApp__/Makefiles/

This level contains commands that are executed directly inside the Rails container. Commands have similar names to host commands but are executed in the container context:

# Commands inside container
make setup      # Rails application setup
make console    # Rails console
make db-migrate # Database migrations
make server     # Start Rails server
make bundle     # Install gems

Main functions:

Rails-specific commands
Database management
Dependency management (bundler)
Generators and testing
Direct execution in Rails application context

Modular Structure

Each level is organized with sets of Makefile files with specific purposes for better structure and maintenance:

rails-start/
├── Makefiles/                   # Host level
│   ├── 100_Project.mk           # Docker and project management
│   ├── 200_Rails.mk             # Rails command delegation
│   ├── 300_Rails-Production.mk  # Production environment
│   └── 400_env.mk               # Environment variables management
│
└── __RailsApp__/
    └── Makefiles/               # Container level
        ├── 100_Project.mk       # Common container commands
        ├── 200_Rails.mk         # Rails development
        └── 300_Production.mk    # Production commands

Host level:

100_Project.mk - Docker and project management
200_Rails.mk - Rails command delegation
300_Rails-Production.mk - Production environment
400_env.mk - Environment variables management

Container level:

100_Project.mk - Common container commands
200_Rails.mk - Rails development
300_Production.mk - Production commands

Advantages of This Approach

1. Command Uniformity at Different Levels

Thanks to unified command names, developers can use similar commands both on the host and inside the container:

# On host
make rails-console     # Delegates to container
make rails-db-migrate  # Delegates to container

# Inside container (after make rails-bash)
make console           # Executes directly
make db-migrate        # Executes directly

2. Ease of Use

# Instead of complex command:
docker compose -f ./docker/docker-compose.yml exec rails_app bundle exec rails db:migrate

# Simply:
make rails-db-migrate

3. Command Unification Across Operating Systems

Whether you work on macOS, Linux, or Windows (via WSL), the commands remain the same.

4. Self-Documentation

make help                   # General help
make rails-help             # Rails commands
make project-help           # Project management
make rails-production-help  # Production commands

5. Transparent Command Delegation

Host commands are automatically delegated to containers, maintaining interface uniformity:

# On host (Makefiles/200_Rails.mk)
rails-console:
    docker compose -f $(COMPOSE_FILE) exec rails_app make console

rails-db-migrate:
    docker compose -f $(COMPOSE_FILE) exec rails_app make db-migrate

# In container (__RailsApp__/Makefiles/200_Rails.mk)
console:
    bundle exec rails console

db-migrate:
    bundle exec rails db:migrate

This architecture allows developers not to think about where exactly the command is executed - the system automatically chooses the right context.

Practical Examples

Quick project start:

git clone https://github.com/the-teacher/rails-start.git
cd rails-start
make rails-start  # All ready!

Daily development:

make rails-console     # Open Rails console
make rails-db-migrate  # Run migrations
make rails-logs        # View logs
make rails-status      # Check processes

Database operations:

make rails-db-create   # Create database
make rails-db-seed     # Seed with data
make rails-db-reset    # Full reset (with warning)

Generators and testing:

make rails-bash                             # Enter container
make generate-model name=User               # Create model
make generate-controller name=Users         # Create controller
make test                                   # Run tests

Conclusion

Makefile is not commonly found in Rails projects, and this technology is not very widespread for working with Rails applications. However, the RailsStart project shows an example of an effective and elegant solution for running Rails on any operating system.

Makefile in the RailsStart project doesn't just simplify commands - it creates a unified management interface for the entire Rails application lifecycle.

The two-level architecture provides clear separation of responsibilities between infrastructure management (host) and application development (container).

This solution is especially valuable for:

Development teams - workflow unification
New project members - quick understanding of available commands
DevOps practices - deployment standardization
Rails learning - focus on development rather than environment setup

RailsStart proves that a properly organized Makefile can transform a complex Docker + Rails environment into a simple and intuitive development tool.

Glossary

Host machine - a physical or virtual computer on which Docker and other software runs. In the context of the article - your working machine (macOS, Linux, Windows).

Container - an isolated application runtime environment created using containerization technology. Contains the application and all its dependencies.

Docker - a platform for developing, delivering, and running applications in containers. docker.com

Docker Compose - a tool for defining and running multi-container Docker applications. docs.docker.com/compose

Make - a build automation utility for managing compilation and command execution. gnu.org/software/make

Makefile - a configuration file for the Make utility, containing rules and commands for task automation.

Rails (Ruby on Rails) - a web framework for the Ruby programming language. rubyonrails.org

Git - a distributed version control system. git-scm.com

WSL (Windows Subsystem for Linux) - a Windows subsystem for Linux that allows running a Linux environment on Windows. docs.microsoft.com/windows/wsl

How to Install Ruby on Rails 8 on Windows

Ilya N. Zykin — Wed, 01 Oct 2025 07:05:09 +0000

Rails Start!

"Rails Start" is a starter kit for Ruby on Rails applications, designed to help developers quickly set up a new project with essential features and best practices.

This project is a perfect choice for:

Enterprises looking to standardize their Rails application setup.
Freelancers and agencies to kickstart client projects.
Online education platforms to start teaching Ruby on Rails.
Individual developers who want a solid foundation for their Rails applications.

Requirements

Docker and Docker Compose installed on your machine.
git installed (usually comes pre-installed on MacOS and Linux).
make utility installed (usually comes pre-installed on MacOS and Linux).
WSL2 (For Windows users) with a Linux distribution (like Ubuntu) is recommended.

How to Use (MacOS / Linux)

git clone https://github.com/the-teacher/rails-start.git
cd rails-start
make rails-start

That is it! Very simple!

Now visit: http://localhost:3000 in your browser.

How to Use (Windows WSL2)

Open cmd or PowerShell and run:

Install WSL2 and Ubuntu (if not installed yet):

wsl --install
wsl --set-default-version 2
wsl --install -d Ubuntu

Run WSL and install make:

wsl
sudo apt-get install -y make

git clone https://github.com/the-teacher/rails-start.git
cd rails-start
make rails-start

That is it! Very simple!

Now visit: http://localhost:3000 in your browser.

miniframe-router: Router for Express.JS Applications

Ilya N. Zykin — Mon, 30 Dec 2024 12:11:09 +0000

miniframe-router — a minimalist router for Express.JS applications, inspired by Ruby on Rails. Here’s how I made it.

Example of how routing might look in a simple application.

// Root routes
root("index#home");

// Basic CRUD routes
get("/users", "users#index");
get("/users/:id", "users#show");
post("/users", "users#create");
post("/users/:id", "users#update");
post("/users/:id/destroy", "users#destroy");

// Posts routes with scope
scope("blog", () => {
  get("/posts", "posts#index");
  get("/posts/:id", "posts#show");
  post("/posts", "posts#create");
  post("/posts/:id", "posts#update");
  post("/posts/:id/destroy", "posts#destroy");
});

Context

I hadn’t written NodeJS applications for about 10 years. Curious about Telegram Mini Apps, I decided to build a few simple projects to explore this new field.

For this, I needed routing for the backend of my applications. Existing solutions didn’t quite impress me, so I decided to create my own router — simple, effective, and inspired by Ruby on Rails. It was also a great opportunity to refresh my knowledge of creating NPM packages, something I hadn’t done in 9 years.

Design

Expectations for the Router:

Routing is defined in a separate file

This simplifies the application structure and avoids cluttering the main application file.

import {
  root,
  get,
  post,
  routeScope as scope,
  getRouter,
} from "miniframe-router";

// Root routes
root("index#home");

// Basic CRUD routes
get("/users", "users#index");
get("/users/:id", "users#show");
post("/users", "users#create");
post("/users/:id", "users#update");
post("/users/:id/destroy", "users#destroy");

// Posts routes with scope
scope("blog", () => {
  get("/posts", "posts#index");
  get("/posts/:id", "posts#show");
  post("/posts", "posts#create");
  post("/posts/:id", "posts#update");
  post("/posts/:id/destroy", "posts#destroy");
});

export default getRouter;

The router integrates into the main ExpressJS file

A simple and effective entry point for the application: src/index.js or src/main.js.

import express from "express";
import getRouter from "./routes"; // <<< DEFINE ROUTES

const app = express();
app.use(express.json());
app.use(getRouter()); // <<< APPLY ROUTES

app.listen(3000, () => {
  console.log("Demo app is running on http://localhost:3000");
});

Following conventions for connecting controllers

Controllers are located in the src/controllers directory.

MyApp
└── src
    ├── controllers
    │   ├── blog
    │   │   └── postsController.ts
    │   ├── indexController.ts
    │   └── usersController.ts
    ├── index.ts
    └── routes
        └── index.ts

File Structure

Routes are defined in src/routes/index.js.
Controllers contain the logic for handling requests:

Example: src/controllers/usersController.ts (or .js).

import { Request, Response } from "express";

export const index = (req: Request, res: Response) => {
  res.send("List of all users");
};

export const show = (req: Request, res: Response) => {
  const { id } = req.params;
  res.send(`Showing details for user ${id}`);
};

export const create = (req: Request, res: Response) => {
  const userData = req.body;
  res.send(`Creating new user with data: ${JSON.stringify(userData)}`);
};

export const update = (req: Request, res: Response) => {
  const { id } = req.params;
  const userData = req.body;
  res.send(`Updating user ${id} with data: ${JSON.stringify(userData)}`);
};

export const destroy = (req: Request, res: Response) => {
  const { id } = req.params;
  res.send(`Deleting user ${id}`);
};

Implementation

Steps:

Create a development container using Docker.
Set up ESBuild for compiling TypeScript to JavaScript.
Install Jest for testing.
Write tests to validate the first version of the router.
Implement the router until all tests pass.
Recover my long-unused NPM credentials (after 9 years).
Publish the NPM package as version 1.0.0.
Fix critical installation bugs and remove versions 1.0.0 and 1.1.0. 😄
Apply the router to a production project with a dozen routes.

Q&A

Why even do this? There are so many existing solutions!

It’s interesting, useful, and contributes to diversity in solutions.

Why so simple? Shouldn’t it be more complex?

Following the KISS principle. Complexity can be added later as needed.

Why controllers? Aren’t they unnecessary?

Controllers are convenient for small projects. Higher abstractions like Action/Operation-like solutions are better suited for larger systems.

Is this solution even functional?

Absolutely! The router was used in a small production app and performed perfectly with dozens of routes.

What size projects can it handle?

miniframe-router is suitable for applications with dozens of routes. There are no strict size limitations.

Conclusion

Project code and documentation: GitHub - miniframe-router

NPM package: miniframe-router

Like, share, and subscribe! Constructive feedback is always welcome.

Author's page: GitHub - the-teacher

Vue. Slots. First touch

Ilya N. Zykin — Wed, 17 Jan 2024 13:09:34 +0000

First time I met using slots in Vue.js

I wanted to figure out how it works, because I could not develop tests without a deep understanding of this concept.

Let's see how it works

components/MyComponent.vue

<script setup>
const greetingMessage = 'hello';
const someNumber = 123;
</script>

<template>
  <div>
    <slot name="header" :text="greetingMessage" :count="someNumber"></slot>
    <slot :text="greetingMessage" :count="someNumber"></slot>
    <slot name="footer" :text="greetingMessage" :count="someNumber"></slot>
  </div>
</template>

App.vue

<script setup lang="ts">
import MyComponent from './components/MyComponent.vue';
</script>

<template>
  <MyComponent>
    <template #header="headerProps">
      <p>HEADER: {{ headerProps }}</p>
    </template>

    <template #default="defaultProps">
      <p>DEFAULT: {{ defaultProps }}</p>
    </template>

    <template #footer="{ text, count }">
      <p>FOOTER: {{ text }} = {{ count }}</p>
    </template>
  </MyComponent>
</template>

Slots inside Components

By default a slot works as a { children } parameter in React components. It provides a way to take a content of a Component (<MyComponent>CONTENT HERE</MyComponent>) and place it inside internals of the component.
In a component Slot reserves a place where a content will be placed, if the content comes from the parent level.
A component may have multiple slots inside
Slot without a name, by default has name default

Slots outside Components

WOW! From the inside of the component slots may pass data on the level of parent.

<slot name="header" :text="hello">

passes the text variable to template (to the upper level)

<template #header="headerProps">

now inside <template #header> you can use

{{ headerProps.text }}

WOW! Ordering of slots inside a component defines an order outside, and affects on ordering of templates.

Even if here we have an order: header, default, footer

  <MyComponent>
    <template #header="headerProps">
      <p>HEADER: {{ headerProps }}</p>
    </template>

    <template #default="defaultProps">
      <p>DEFAULT: {{ defaultProps }}</p>
    </template>

    <template #footer="{ text, count }">
      <p>FOOTER: {{ text }} = {{ count }}</p>
    </template>
  </MyComponent>

but if we define the order of slots like that footer, header, default:

    <slot name="footer" :text="greetingMessage" :count="someNumber"></slot>
    <slot name="header" :text="greetingMessage" :count="someNumber"></slot>
    <slot :text="greetingMessage" :count="someNumber"></slot>

Then it will produce the result

FOOTER: hello = 123

HEADER: { "text": "hello", "count": 123 }

DEFAULT: { "text": "hello", "count": 123 }

It was pretty unexpected to me.

Playground

Happy Coding!

Rails 7. Start Kit Loves Nginx

Ilya N. Zykin — Mon, 18 Sep 2023 08:14:51 +0000

Rails 7. Start Kit is a great choice for any kind of startups and developers who wants to save time in launching a new Rails application on any platform.

At this weekend I've added NGINX to my start kit setup.

Time to time it is important to debug and check an application in mode that is close to the real production environment. Using NGINX helps to do it. I have added certificates to provide access via https.

In this PULL REQUEST You can check changes related to the enhancement.

/etc/hosts

To have an access to the project on local machine do not forget config your /etc/hosts file

How it looks

http	https	certificate

Naming and Conventions note

Time to time people ask me, - "Why do you name configuration files so?". They mean that I underscore and uppercase some configuration files and folders like you can see it here:

I do it to highlight some important configuration files, folders and other stuff for demonstration and education purposes.

If you do not like naming like that or my way to place configuration files - you always can change it following your personal preferences.

One-liner for launching `Ruby on Rails`

❤️ Linux / MacOS

git clone https://github.com/the-teacher/rails7-startkit.git && \
  cd rails7-startkit && \
  ruby bin/setup

💙 Windows

git clone https://github.com/the-teacher/rails7-startkit.git & cd rails7-startkit & ruby bin/setup

Prerequisites

On your host you have to have:

Any version of Ruby
Any version of Git
Any version of Docker

Like, Share, Tell to your Colleagues

👉 The project needs for your help to make it helpful for as much people is it possible.

Please Like 👍 , Share 💁 and Tell 📣 to your Colleagues!

❤️ Happy coding with Rails 7. Start Kit

RubyMine. How to remove trailing whitespaces

Ilya N. Zykin — Mon, 22 May 2023 08:29:51 +0000

I noticed that by default my new code editor does not remove trailing whitespaces. There is the setting is placed!

Happy coding!

RubyMine. How to Increase/Decrease font size

Ilya N. Zykin — Mon, 15 May 2023 07:41:49 +0000

To change the font size in the editor you need to press SHIFT + CONTROL and point or comma

Happy Coding

RubyMine. How to Show/Hide terminal panel

Ilya N. Zykin — Sun, 14 May 2023 13:16:10 +0000

This nice Terminal panel does not show/hide when you just press OPTION key + F12 as it is described in a tooltip

It is because on MacOS functional keys are being used by operation system. For example to control sound.

You can just turn this behaviour off. I do not like the idea because I like it.

To use OPTION key + F12 you just need to use FN key as well.

The final combo is FN key + OPTION key + F12

Happy Coding!

RubyMine. How to Open a Folder with a Single Click

Ilya N. Zykin — Sun, 14 May 2023 06:52:32 +0000

Jetbrains gave me a license for developing my OpenSource project.

To make my development experience better I set up the option - Open files with Single Click

Surprisingly there is no an option to do the same with Folders

https://youtrack.jetbrains.com/issue/IDEA-142105

Fortunately there is an old but old plugin to manage it

https://plugins.jetbrains.com/plugin/12778-quick-file-preview

Now everything works like I want.

Happy Coding!

RSpec. let and let!

Ilya N. Zykin — Mon, 24 Apr 2023 18:31:20 +0000

After years being out of the Rails ecosystem I was curious what is the difference between let and let! in rspec tests. I just forgot.

There is a simple case to demonstrate:

require 'rails_helper'

RSpec.describe User, type: :model do
  describe 'Creating.' do
    let!(:user) { create(:user) }

    it 'Exists' do
      expect(User.count).to eq 1
    end
  end
end

  1) User Creating. Exists
     Failure/Error: expect(User.count).to eq 1

And with let!

require 'rails_helper'

RSpec.describe User, type: :model do
  describe 'Creating.' do
    let!(:user) { create(:user) }

    it 'Exists' do
      expect(User.count).to eq 1
    end
  end
end

It gives: User Creating. Exists

Conclusion

With let we create an object when we first time to use it.

With let! we create an object when we declare it.

Happy Coding!

How to write a View test in Rails with RSpec

Ilya N. Zykin — Fri, 21 Apr 2023 16:49:28 +0000

I want to write a View test. What should I do?

Step 1. Learn the view template

<% content_for :head do %>
  <title>Project Name</title>

  <link
    rel="preload"
    as="image"
    href="<%= vite_asset_url 'images/logo.jpg' %>"
  />
<% end %>

<% @blogs.each_with_index do |blog| %>
  <li><%= blog.title %></li>
<% end %>

Here I see

View variable @blogs
Rails helper vite_asset_url

Step 2. How to `stub` a rails helper?

To do that I'm going to use the following way. Here in view I stub vite_asset_url and it will return a string "vite_asset_url".

allow(view).to
  receive(:vite_asset_url).and_return("vite_asset_url")

Step 3. How to `stub` a view variable?

To do that I use assign test helper.

assign(:blogs, [blog1, blog2, blog2])

Step 4. How a test should look?

It looks like that:

require 'rails_helper'

RSpec.describe "site/landing/index", type: :view do
  let!(:published_blogs) do
    create_list(:blog, 3, :published, :for_blog) do |blog, index|
      blog.title =  "Blog Title #{index.next}"
      blog.save!
    end
  end

  before do
    allow(view).to
      receive(:vite_asset_url).and_return("vite_asset_url")
  end

  it "renders attributes in show page" do
    assign(:blogs,  published_blogs)

    render

    expect(rendered).to match(/Blog Title 1/)
    expect(rendered).to match(/Blog Title 2/)
    expect(rendered).to match(/Blog Title 3/)
  end
end

That is it!
Happy Coding!

Testing Rails root route

Ilya N. Zykin — Fri, 21 Apr 2023 11:29:44 +0000

Now I need to test a root route in a Rails App

Step 1. Learning the routing file

File: config/routes.rb

Rails.application.routes.draw do
  root to: 'root#index'
end

Step 2. Adding a test

File: spec/routing/root_spec.rb. This time I didn't use describe, only it.

root_path is a Rails routing helper that is equal to /.

require 'rails_helper'

RSpec.describe 'Root Route', type: :routing do
  it 'leads to a correct controller and action' do
    get(root_path).should route_to("root#index")
  end

  it 'does not exist' do
    expect(post: root_path).not_to be_routable
  end
end

Step 3. Running the spec

bundle exec rspec spec/routing/root_spec.rb --format documentation

That is it!
Happy coding!

DEV Community: Ilya N. Zykin

How Makefile Helps Rails Developers

Introduction

What are Make and Makefile?

What do you need to run Rails Start?

Why do I use Make instead of Ruby scripts?

Two-Level Makefiles Architecture

1. Host Level (Project)

2. Container Level

Modular Structure

Host level:

Container level:

Advantages of This Approach

1. Command Uniformity at Different Levels

2. Ease of Use

3. Command Unification Across Operating Systems

4. Self-Documentation

5. Transparent Command Delegation

Practical Examples

Quick project start:

Daily development:

Database operations:

Generators and testing:

Conclusion

Glossary

How to Install Ruby on Rails 8 on Windows

Rails Start!

How to Use (MacOS / Linux)

How to Use (Windows WSL2)

miniframe-router: Router for Express.JS Applications

Context

Design

Expectations for the Router:

File Structure

Implementation

Steps:

Q&A

Why even do this? There are so many existing solutions!

Why so simple? Shouldn’t it be more complex?

Why controllers? Aren’t they unnecessary?

Is this solution even functional?

What size projects can it handle?

Conclusion

Vue. Slots. First touch

Slots inside Components

Slots outside Components

Rails 7. Start Kit Loves Nginx

/etc/hosts

How it looks

Naming and Conventions note

One-liner for launching Ruby on Rails

Prerequisites

Like, Share, Tell to your Colleagues

RubyMine. How to remove trailing whitespaces

RubyMine. How to Increase/Decrease font size

RubyMine. How to Show/Hide terminal panel

RubyMine. How to Open a Folder with a Single Click

RSpec. let and let!

Conclusion

How to write a View test in Rails with RSpec

Step 1. Learn the view template

Step 2. How to stub a rails helper?

Step 3. How to stub a view variable?

Step 4. How a test should look?

Testing Rails root route

Step 1. Learning the routing file

Step 2. Adding a test

Step 3. Running the spec

Two-Level `Makefiles` Architecture

One-liner for launching `Ruby on Rails`

Step 2. How to `stub` a rails helper?

Step 3. How to `stub` a view variable?