My parents recently started producing dairy products in their small farm and wanted a way to better manage the inventory and sales. Initially the workflow was:

• Write down orders from friends and family;
• Produce the products;
• Deliver the orders and receive payments.

Their struggle was mainly with order management, as they had to keep track of the orders, the products needed to produce them, and payment and deliver status. They asked me to help them with a solution, and I thought it would be a good opportunity to put in practice some of the things I recently learned about Ruby on Rails.

The stack

The project started with the following stack:

• Rails 8 with Ruby 3.3.5;
• SQLite3 for development, testing, and production;
• Turbo and Stimulus for the frontend;
• css-zero for styling;
• solid-queue/solid-cache/solid-cable for background jobs, caching, and websockets;
• authentication-zero to bootstrap some authentication features.

Development process

The initial features of the application were a way to manage customers, products, and orders. The schema of the application was as follows:

The application was intended to be used only by my parents, so I didn’t create any tenant relationship between users and the other models.

When I got the initial version working, I needed a way to deploy and make the application available to them. Since I’ve been hearing a lot about Kamal, I decided to take a stab. Created a VPS at Hetzner, configured my DNS, added the configuration to the YML file, and ran the deploy command. After some struggles with Cloudflare SSL, the application was up and running.

They got very excited about what I had built, and started to request features. One of cool things I could experience was the feedback loop. They came to me with a problem, and I as the PM/Dev/CEO/CTO had to come up with a solution. The end user is very good at describing the problems they have, but usually not great at proposing solutions. So I had to come up with ideas that would solve their problems and be feasible with the technology I was using and time available that I had.

Current state

They have been using the application for a couple of months now, and I was able to add some new features, such as:

• Multi-tenancy: introduced the concept of organizations/memberships, so in the future the application can support other sub-companies outside the dairy domain;
• Backups: integrated Litestream to the application to make sure no data would be lost in the event of a VPS/storage failure;
• Active storage: added the ability to upload images to products;

Some other small quality of life features were also added like basic payment integration with Pix payment links, a simple dashboard with some metrics, a public order and menu page, and a way to add product variants to each of the products.

The latest change to the application was the addition of support to the PWA standard, so it can be installed on their phones and used offline. This was done using the workbox library by Google, that made managing the service worker and caching strategies very easy. This combined with View Transitions (from Turbo) made the application feel very snappy and responsive.

Demo

Here’s a small demo of the application:

Conclusion

• Hetzner + Kamal was pretty easy to setup and deploy. One thing I missed was to have metrics to monitor the current state of the VPS and the application;
• css-zero is straightforwad to use and the examples are very good. Not having to think much about styling was a good thing for this project;
• Cloudflare worked great for me, specifically to manage DNS and caching. Rails’ defaults work in harmony with Cloudflare’s caching strategies and nothing needs to be configured to get CDN benefits;
• Litestream is an incredible tool. After I discovered it I went into the SQLite rabbit hole, leaning more about Ben Johnson, and all the cool use cases that are currently available for modern SQLite;

I had the amazing opportunity to be at Rails World 2024 in Toronto, CA. It was my first time in Canada and attending an international conference. I had the opportunity to meet some very nice people, and chat about one of the things I most enjoy doing: programming. Being there was a confirmation of the incredible community behind the Ruby on Rails ecosystem. People that not only love technology, but also the journey of building web applications with tools that bring joy to programmers.

All the talks are now available at Rails World’s Youtube channel.

Kamal and #NoPaaS

One of the most mentioned topics in the conference was the “NoPaaS” concept; it means to deploy your application without the need of platforms like Heroku, Render, and Railway (not to mention solutions that require a separate DevOps team to manage and understand it all). This concept connects well with the new tools that will be defaults for new Rails 8 apps:

• Kamal: deploy Dockerized apps anywhere with SSH access;
• “Solid Stack”: database backed libraries that take advantage of fast hard drives and new DBMS features:
  • Solid Queue;
  • Solid Cache;
  • Solid Cable;
• SQLite by default and production ready.

Kamal also allows you to run and manage you own “accessories” such as databases, cache storages, and other services that complement your application. I’m not sure if I would trust myself to run my own Postgres instance in production from scratch, specially when I consider that managed solutions like Managed Databases fro DigitalOcean start as low as $15 with a lot of out-of-the-box features; but it’s definitely a powerful tool.

More on production SQLite for web servers

We all know that, by default, SQLite is not suitable to web applications. SQLite defaults aim to be as backwards compatible with the 2000’s version as possible and it really shines with web frameworks like Rails when correctly configured to handle the concurrent access. Rails 8 + SQLite + Kamal is a killer stack for new companies when we consider that:

1. All you need to get the first version of your app to the world (w/ caching, async jobs, and real-time updates) is a $5 VPS and Kamal;
2. Simple infrastructure means more time for developers to focus on building new features;
3. Clear path to overcome bottlenecks (and migrate off SQLite if needed).

Strive for conceptual and operational compression

The Rails community really cares about about simplicity, and sees complexity as the bridge to progress. Not because we want to build simple applications, but because we want to build complex application using the simplest (and most enjoyable) solution possible. That’s one of the reasons why people choose monoliths over microservices: not because microservices are bad, but because monoliths are the simplest way to get things done.

Engineering teams should optimize development for their current team size and commit to never rewrite their apps. With this mindset you can archive:

• Applications that live longer and healthier;
• Developers that can focus on a single codebase to build features and share knowledge;
• Use resources as efficient as possible.

If you feel uncomfortable with the amount of time you spend in social media apps like Instagram browsing through ads and algorithmic content, you’re not alone. A lot of times I find myself unconsciously scrolling my timeline (or clicking across Stories) and loosing track of time. Here is an alternative to be up-to-date with the content you find relevant, without the distractions that these apps are famous for.

RSS to the rescue

RSS allows users and applications to access updates to websites in a standardized, computer-readable format. This means that you can have updates from websites without actually accessing them. Here’s an example of a RSS feed:

<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">
<channel>
 <title>RSS Title</title>
 <description>This is an example of an RSS feed</description>
 <link>http://www.example.com/main.html</link>
 <copyright>2020 Example.com All rights reserved</copyright>
 <lastBuildDate>Mon, 6 Sep 2010 00:01:00 +0000</lastBuildDate>
 <pubDate>Sun, 6 Sep 2009 16:20:00 +0000</pubDate>
 <ttl>1800</ttl>

 <item>
  <title>Example entry</title>
  <description>Here is some text containing an interesting description.</description>
  <link>http://www.example.com/blog/post/1</link>
  <guid isPermaLink="false">7bd204c6-1655-4c27-aeee-53f933c5395f</guid>
  <pubDate>Sun, 6 Sep 2009 16:20:00 +0000</pubDate>
 </item>

</channel>
</rss>

To convert this file to human-readable format a news reader or aggregator is used. Aggregation technology consolidates many websites into one page that can show only the new or updated information from many sites.

How to get started

1. Find an aggregator that suits you

There are plenty of free and paid options out there, search for feed aggregator and choose one. Almost all of them provide an option to import and export, so don’t hesitate to experiment with different apps.

My personal choice is to self-host yarr (https://github.com/nkanaev/yarr)

2. Search for the content feeds you like

This is probably the hardest part :( There’s a lot of data that is only available inside platforms, and not accessible without actually using the proprietary Apps (Meta is excellent in this matter). Here are some tips to find content that matters to you:

• YouTube channels https://www.youtube.com/feeds/videos.xml?channel_id=
• Reddit
  • Front page: http://www.reddit.com/.rss
  • A subreddit: http://www.reddit.com/r/news/.rss
  • Private feeds: https://www.reddit.com/prefs/feeds
• Weather
  • https://www.bbc.com/weather/about/17543675
• HackerNews
  • https://hnrss.github.io/
• GitHub releases
  • https://github.com/jellyfin/jellyfin/releases.atom
• News
  • Almost all news website have a feed, search for rss <news provider>

    Pro tips

• RSSHub is great to get feeds for stuff that is not easily available like Telegram channels, Spotify-only podcasts, etc.
  • I self-host it myself and it saves me a lot with content from “the outside”
• Change the FOMO mentality; don’t beat yourself you for not being able to keep every reading up-to-date, or to miss a couple of posts. If it’s something really important, I’m sure the information will get to you in time :)

Social media is usually (by the time I write this post) represented by big tech companies that control the content and data generated from the users of the platform. However, recently, we’re seeing a shift towards decentralized alternatives that may change the way we interact with social services.

When choosing a social network, we usually have three main considerations:

• Format: networking, microblogging, link-aggregator, media sharing, short videos, etc
• Content: what content is being produced, and who’s interacting with it
• Owner: who dictates the rules and owns the data

The common pattern is to usually have only one or two alternatives for each social media format as we know: Facebook, Twitter, Reddit, Instagram, YouTube, TikTok; all owned by huge companies. People tend to go where the content is, but what if content could be shared across media platforms?

Meet the ActivityPub protocol

ActivityPub is an open, decentralized social networking protocol. It provides a client/server API for creating, updating, and deleting content, as well as a federated server-to-server API for delivering notifications and content. It was developed by the W3C Consortium and launched in 2018.

In summary, ActivityPub allows social networks to integrate and share stuff. This represents a decentralized model, where the content is spread across multiple “instances” but can be accessed by anyone in the “federated” network.

Implementations

Here are some open-source implementations of the ActivityPub:

• Mastodon: microblogging
• PeerTube: video platform
• Pixelfed: image and video sharing
• Lemmy: news aggregators and discussion forums

For each one of these, you can choose different instances to create your account and interact with content from all of the other connected/federated instances. The instance you choose will hold your data and moderate the content generated by it’s users and communities.

The instance owner can also decide whether or not block communication with other instances. If this happens, content is not accessible from one to the other and vice-versa. This process is called “defederation” and can happen when there’s a lack of trust between different instances, and/or to prevent spam, illicit activities, and so on.

The future of the Fediverse

The future of the universe of ActivityPub implementations (also known as Fediverse or Federated universe) is unknown. The reality is that we have a mix of open-source applications, and Meta is coming to the game with Threads. Here are a few questions that only time can answer:

• How the current fediverse (open-source projects) will react to the addition of Threads? Will we see a mass “defederation”?
• What’s Meta’s goal with federation? They’ll have access to a lot of user data for free, but will this be enough? Can we expect an Embrace, extend, and extinguish strategy?
• What’s the next “big addition” to the fediverse? Can we expect Reddit, Twitter, and other media companies to have their own implementations of the protocol?

Before we start, let’s explain some of the terminology that will be used in this text:

Raspberry Pi

Is a series of small single-board ARM-based computers. This experiment used the Raspberry Pi 4 Model B with 2GB of RAM.

Plex Media Server

Is a free software that allows users to create a client–server for movies, television shows, and music. Plex Media Server organizes movie and television content and adds posters, plot summaries, cast and crew lists, technical details, critical reviews, and subtitles. Plex Media Server is also capable of transcoding files if the codec is incompatible with the device playing the media.

A Plex Media Server can function as a home theater PC and can stream content to Plex’s front-end media player client applications that run on a myriad of devices and web browsers.

Cloudflare Zero Trust

Provides the power of Cloudflare’s global network to your internal teams and infrastructure. Cloudflare Zero Trust empowers users with secure, fast and seamless access to any device on the Internet.

Cloudflare Tunnel

Establishes a secure outbound connection which runs in your infrastructure to connect the applications and machines to Cloudflare. Removes the need to configure IP addresses and ports to access your self-hosted applications.

First things first

1. Create your Plex account

Go to https://www.plex.tv/sign-up/ and sign up.

2. Create your Cloudflare account and add your domain

You can create your Cloudflare account at https://dash.cloudflare.com/sign-up, and configure your domain with this guide: https://developers.cloudflare.com/fundamentals/get-started/setup/add-site/

3. Flash Raspberry Pi OS

Install Raspberry Pi Imager from https://www.raspberrypi.com/software/ and flash Raspberry Pi OS into your SD Card.

Media server up and running

You can install Plex Server with an official Plex package repository.

You may need to install HTTPS support for APT

sudo apt-get install apt-transport-https

• Enable repository updating for supported Linux server distributions (DEB-based distros).
• sudo apt-get install plexmediaserver
• Go to http://localhost:32400/web and finish you configuration

All Cloudflare things

We want to be able to configure our media server from anywhere we need. This section will go through the configuration proccess to have an SSH shell accessible from anywhere, with proper auth and without oppening ports from our router.

Cloudflare Zero Trust will be used to manage access, and can be initialized by clicking in the sidebar button at your dashboard

Create an application

After adding your payment method, you will be redirected to the Cloudflare One dashboard. The first step is to add an application:

• Go to Access -> Applications -> Add an application
• Select Self-hosted
• Name your application and set the domain to something like myssh.yourdomain.com
• Setup your access policy, more information at https://developers.cloudflare.com/cloudflare-one/policies/access/
• In Settings, select SSH as the Browser rendering option

Create a tunnel

The next step is to create a tunnel, so your application can be redirected to your Raspberry Pi network:

• Go to Access -> Tunnels -> Create a tunnel
• Name your tunnel and follow the instruction to install and run the connector
• Add a public host name that matches the one you added to your Application, like myssh.yourdomain.com
• Select SSH as the service type
• Protect your public hostname with Access (select the application you just created)

Edit: Pinata has restricted HTTP uploads, so this guide is deprecated :(

A peer-to-peer hypermedia protocol designed to preserve and grow humanity’s knowledge by making the web upgradeable, resilient, and more open.

or

IPFS is a distributed system for storing and accessing files, websites, applications, and data

IPFS allow users to host files in a peer-to-peer network with unique identification and content linking. It takes several good ideas from projects like BitTorrent, Git, Bitcoin, the web, and gathers them in a single tool. To learn more about IPFS visit the docs.

To understand this guide, we need to explain some concepts:

• A Node or peer is the IPFS program that you run on your local computer to store/cache files and then connect to the IPFS network;
• Pinning is the method of telling an IPFS node that particular data is important and so it will never be removed from that node’s cache;
• A Content Identifier (CID) is a self-describing content-addressed label used to point to the data stored in IPFS;
• An IPFS Gateway acts as a bridge between traditional web browsers and IPFS. Through the gateway, users can browse files and websites stored in IPFS as if they were stored on a traditional web server;
• DNSLink uses DNS TXT records to map a DNS name, like ipfs.io, to an IPFS address. Because you can edit your DNS records, you can use them to always point to the latest version of an object in IPFS. Since DNSLink uses DNS records, you can assign names, paths, and sub-domains that are easy to type, read, and remember.

Example

If you want to access a Wikipedia article, the URL usually looks like this

https://en.wikipedia.org/wiki/InterPlanetary_File_System

When using IPFS, we don’t specify where the file is (location based), we ask for a specific file hash (content based) like

/ipns/k51qzi5u.../wiki/InterPlanetary_File_System

Hosting websites on IPFS

The main idea here is to host a full HTML/CSS/JS website using: a service for pinning files on the IPFS network (so we don’t need to run our own node), an IPFS Gateway (so users can access our website from their browsers) and a DNSLink entry (so a friendly URL will be possible). The chosen tools for this process are:

• Pinata
• Cloudflare distributed gateway
• Cloudflare DNS

First, you will need to upload your website files to Pinata, usually the build/ directory. After that, you will be able to view your website online. Something like https://gateway.pinata.cloud/ipfs/QmWAJbBDon9Q....

After that, login to Cloudflare and setup the following entries to your DNS:

Now you should be able to access your website using your own domain :)

Integrate with GitHub Actions

Basically, two steps will be needed:

1. Upload and pin files to IPFS
2. Update your DNSLink record

For the first, we can use upload-to-ipfs action. It is pretty straight forward and integrates well with Pinata.

For the second one, if your DNS is on Cloudflare, we can use its API, specifically the dns-records-for-a-zone-update-dns-record method/endpoint.

Your YML file should look something like this

- name: Upload to IPFS
  uses: aquiladev/ipfs-action@cb917...
  id: upload-ipfs
  with:
    path: ./build
    service: pinata
    pinataKey: $secrets.PINATA_KEY
    pinataSecret: $secrets.PINATA_SECRET
    pinataPinName: Name

- name: Update DNSLink on Cloudflare
  env:
    CLOUDFLARE_ZONE_ID: $secrets.CLOUDFLARE_ZONE_ID
    CLOUDFLARE_DNS_ID: $secrets.CLOUDFLARE_DNS_ID
    CLOUDFLARE_API_KEY: $secrets.CLOUDFLARE_API_KEY
    CLOUDFLARE_EMAIL: $secrets.CLOUDFLARE_EMAIL
    IPFS_HASH: $steps.upload-ipfs.outputs.hash
  run: |
    curl --location --request PUT 'https://api.cloudflare.com/client/v4/zones/'"$CLOUDFLARE_ZONE_ID"'/dns_records/'"$CLOUDFLARE_DNS_ID"'' \
    --header 'Content-Type: application/json' \
    --header 'X-Auth-Key: '"$CLOUDFLARE_API_KEY"'' \
    --header 'X-Auth-Email: '"$CLOUDFLARE_EMAIL"'' \
    --data-raw '{
        "type": "TXT",
        "name": "_dnslink",
        "content": "dnslink=/ipfs/'"$IPFS_HASH"'",
        "ttl": 1
    }'

Programs that generate programs

Metaprogramming may allow developers to be more productive by reducing the amount of code that needs to be written manually. It is worth to notice that the way it is built affects (a lot) the productivity.

The two main use cases are:

• Exposing internal execution mechanisms to code as APIs;
• Dynamic text expression execution that contains programming commands.

Examples

Base code generation

#! /bin/sh
echo '#! /bin/sh' > program
for i in $(seq 992)
do
  echo "echo $i" >> program
done
chmod +x program

C/C++ macros

#define RADTODEG(x) ((x) * 57.29578)

Python eval/exec

>>> eval("5 ** 7")
# 78125

>>> program = 'a = 5\nb = 10\nprint("Sum = ", a+b)'
>>> exec(program)
# Sum =  15

In ruby

The Ruby language offers by default multiple ways to “metaprogram”. Here are some real world examples:

Identifying not implemented methods

Useful for generating infinity methods to classes

APIs

• BasicObject/method_missing
• Object/respond_to_missing?

class Roman
  ROMAN_TO_INT = {
    i: 1,
    v: 5,
    x: 10,
    l: 50,
    c: 100,
    d: 500,
    m: 1000
  }.freeze

  def roman_to_int(str)
    # This implementation does not matter :p
    numbers = str.downcase.chars.map { |char| ROMAN_TO_INT[char.to_sym] }.reverse
    numbers.inject([0, 1]) do |result_number, int|
      result, number = result_number
      int >= number ? [result + int, int] : [result - int, number]
    end.first
  end

  private

  def method_missing(method_name)
    str = method_name.to_s
    roman_to_int(str)
  end
end

roman = Roman.new
roman.iii # => 3
roman.cix # => 109

# activesupport/lib/active_support/string_inquirer.rb
# frozen_string_literal: true

require "active_support/core_ext/symbol/starts_ends_with"

module ActiveSupport
  # Wrapping a string in this class gives you a prettier way to test
  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
  # in a StringInquirer object, so instead of calling this:
  #
  #   Rails.env == 'production'
  #
  # you can call this:
  #
  #   Rails.env.production?
  #
  # == Instantiating a new StringInquirer
  #
  #   vehicle = ActiveSupport::StringInquirer.new('car')
  #   vehicle.car?   # => true
  #   vehicle.bike?  # => false
  class StringInquirer < String
    private
      def respond_to_missing?(method_name, include_private = false)
        method_name.end_with?("?") || super
      end

      def method_missing(method_name, *arguments)
        if method_name.end_with?("?")
          self == method_name[0..-2]
        else
          super
        end
      end
  end
end

Dynamically creating methods

Useful mainly when we need to generate methods from a given list

APIs

• Module/define_method

# activerecord/lib/active_record/store.rb#L135
# ...
keys.each do |key|
  accessor_key = "#{accessor_prefix}#{key}#{accessor_suffix}"

  define_method("#{accessor_key}=") do |value|
    write_store_attribute(store_attribute, key, value)
  end

  define_method(accessor_key) do
    read_store_attribute(store_attribute, key)
  end

  define_method("#{accessor_key}_changed?") do
    return false unless attribute_changed?(store_attribute)
    prev_store, new_store = changes[store_attribute]
    prev_store&.dig(key) != new_store&.dig(key)
  end

  define_method("#{accessor_key}_change") do
    return unless attribute_changed?(store_attribute)
    prev_store, new_store = changes[store_attribute]
    [prev_store&.dig(key), new_store&.dig(key)]
  end

  define_method("#{accessor_key}_was") do
    return unless attribute_changed?(store_attribute)
    prev_store, _new_store = changes[store_attribute]
    prev_store&.dig(key)
  end
# ...

module Loggable
  def logger
    @logger ||= default_logger
  end

  private

  def default_logger
    Rails.logger
  end

  %i[info warn debug error].each do |severity|
    define_method severity do |message, *args|
      data = args.first || {}
      data[:class_name] = self.class.name unless data.key?(:class_name)
      logger.send(severity, message, data)
    end
  end
end

Dynamic method calls

Usually for composing method calls with external input

APIs

• Object/send
• Object/public

class Book
  attr_accessor :title, :author, :length

  def assign_values(values)
    values.each_key do |key|
      send("#{key}=", values[key])
    end
  end
end

book_info = {
  title: 'Forrest Gump',
  author: 'Winston Groom',
  length: 300
}

book = Book.new

# vvvvv Not necessary vvvvv
# book.title = book_info[:title]
# book.author = book_info[:author]
# book.length = book_info[:length]

book.assign_values(book_info)

Conclusion

Metaprogramming can become pretty natural and easy to use, that’s when the danger comes, with ultra generic classes and poor understandable code. Take a look at Martin Fowler’s article Is a Ruby Code-base Hard to Understand?