Sustainable Growth

Annual Blog Review: 2023

Every year, I do a personal annual review. This year, I thought why not do the same for my blog, since it has become such an integral part of my life, both personal and professional. This post contains some of the highlights and a list of all the articles I wrote in 2023.

31 min read

It was a busy year for the Write Software, Well blog.

I started the year with the goal of learning and understanding one Ruby/Rails topic every day and write a detailed blog post every week. Happy to say that I well exceeded my humble goal of 52 posts. I wrote 84 posts this year.

What's more, no AI was harmed in writing any of the posts. All the content, including each and every word you see on this blog is researched and crafted by yours truly. Nothing against ChatGPT (I love it), but a personal goal for this blog and writing in public was to improve my writing skills, and I feel much more confident in my writing than before.

In addition, more than half a million people read the blog, which is absolutely mind-blowing. The blog has helped me connect with so many amazing Ruby and Rails developers at all levels, all over the world. I also made many friends on LinkedIn as well as Reddit. P.S. Contrary to popular opinion, Reddit is a wonderfully supportive group of people (at least the Ruby and Rails subreddits!).

However, the real, intangible benefit is that I am a much better Ruby and Rails developer than I was at the beginning of this year. I've always made it pretty clear that this blog is a very selfish endeavor, to become a better developer (and a writer) by trying to explain the concepts in simple words, for the future me. If others find these posts helpful, relevant, or interesting, that's just the icing on the cake.

That said, I really hope you (the subscribers and readers of this blog) learned something new from my writing and can say the same.

I was also surprised by just how big the Ruby and Rails community is and just how many websites and web applications use Ruby and Rails. This was a big revelation I had after writing and maintaining a Ruby and Rails-focused blog for the past two years, and talking to hundreds (if not thousands) of developers across Reddit, LinkedIn, and Email.

If you are on part of Twitter development circles (I am not on Twitter, neither on Mastodon nor Threads - I found my bliss on Reddit and LinkedIn), it's very hard to tell what's real, especially in web development. Certain things are amplified that do not represent reality. All you see is JavaScript, JavaScript, JavaScript. It gives a (mis-guided) impression that everyone's building React front-ends calling GraphQL APIs on Firebase, powered by Next.js/Astro/Remix/Svelte, hosted on Vercel.

The reality couldn't be more different.

I know deep down in my guts the reality is 99.9% of web applications are not that (that number is totally made up btw, to make the point). For most real-world companies and applications that earn real money and aren't just demo SPA projects, full-stack frameworks like Rails (Ruby), Laravel (PHP), ASP.NET (C#), or even good old Java using a MySQL or PostgreSQL database is what powers their tech stack.

So if you're a Ruby, PHP, Python, C#, or Java developer, please don't feel like you have to jump the ship to the server-rendered, React-powered, VC-fuelled JavaScript land. The grass is actually greener here, in the beautiful Ruby and Rails world. There's also much less competition, and the communities are really, really friendly, nice and wonderful.

Okay, rant over. I am just happy that I get to write Ruby and Rails in my little corner and will try to spread the joy of Ruby as much as I can.

Back to the annual review: I also announced the pre-release version of my course on Hotwire. The most surprising thing was the number of people who bought the paid version of the course, even if it was completely free. I am truly grateful to you all 🙏, and be assured that you'll have the full access to the finished and polished course, when I'll launch it next year.

Announcing: Crash Course on Turbo (Hotwire) Framework
Announcing the pre-release of an introductory mini-guide for everyone interested in Hotwire and part of a bigger, more comprehensive, paid Hotwire course that I plan to release next year. This course provides a brief introduction to Hotwire with hands-on, practical projects.

Oh, I also did a major rebranding of the blog! If you are new to Write Software, Well and want to know what this is all about, check out the following post:

Akshay’s Blog is now Write Software, Well
This blog is about writing as much as it is about software development. After two years, 130 posts, and hundreds of thousands of readers, the blog has outgrown my personal domain and needs a new home. Welcome to “Write Software, Well”.

Another highlight was when Matz, creator of Ruby, posted my article on Twitter 🥹

Matz Tweets My Post

Overall, it's been a fantastic year for Write Software, Well. Hopefully, I will get to write a few more words in 2024, so if you'd like to be the part of the journey to not only learn and master, but enjoy the process of writing Ruby and Rails, I hope you subscribe to the blog.

With that, here is every post I wrote this year.


Everything I Learned About Ruby and Rails in 2023

Enqueue Multiple Jobs Together with perform_all_later in Rails
Are you still looping over the list of jobs to enqueue them individually? This post explores the new `perform_all_later` method in Rails, which was introduced in Rails 7.1 and lets you enqueue multiple jobs together to reduce the round-trip to the job backend, like Redis or the database.
Nested Modules in Ruby
There are two different ways to define nested modules in Ruby. This post explains them both along with the differences between them and how to decide which one to use. We will also learn about the `Module.nesting` method, which returns the list of nesting for a module.
Rails Internals: A Deep Dive Into Active Job Codebase
Do you want to understand how Active Job works behind the scenes? Reading and understanding the source code is one of the best ways to learn a framework (or anything). This post breaks it all down for you by tracing the journey of a Rails background job, from its creation to execution.
Working with SQLite in Ruby
SQLite is an incredibly simple yet powerful database both for beginners and advanced users to learn SQL as well as build applications (both desktop and web) that need to store data. In this post, we’re going to cover the basics of working with SQLite in Ruby.
How respond_to Method Works in Rails
The respond_to method allows the controller to select the appropriate response format based on the request’s Accept header or the request URL. You can also use it to handle variants for different screens. This post covers the basics of this method: what it is, how it works and why it’s important.
CDPATH: Easily Navigate Directories in the Terminal
The CDPATH environment variable lets you pre-configure frequently used directories so you can easily navigate into them from anywhere in your file system. This blog post shows how it works and how to use it.
Understanding the Rails Router: Why, What, and How
The router is the entry point of your Rails application. It acts as the gatekeeper for all incoming HTTP requests, inspecting and sending them to a controller action; even filtering and rejecting them if necessary. In this article, we’ll do a deep dive into the Rails Router to understand it better.
Announcing: Crash Course on Turbo (Hotwire) Framework
Announcing the pre-release of an introductory mini-guide for everyone interested in Hotwire and part of a bigger, more comprehensive, paid Hotwire course that I plan to release next year. This course provides a brief introduction to Hotwire with hands-on, practical projects.
How to Customize Rails Validation Errors to Remove Leading Attribute Column Names
Rails validations is an elegant way to verify the model state before it’s saved into the database. Often, you want to provide a custom, user-friendly error message to the user. In this post, we’ll learn how to accomplish this with custom validation methods.
How to Return 404 Not Found Error in Rails
In this post, we’ll learn about the HTTP 404 Not Found error: what it is and how it works, how to return a 404 response from a Rails application with a custom error page, and understand the impact of 404 errors on the SEO for your website or web application.
Interview with Daniela Baron, Staff Engineer at FundThrough
I recently had the pleasure to interview Daniela Baron, a Ruby and Rails developer and staff engineer at FundThrough, a fintech company based in Toronto. It contains a lot of interesting and thoughtful answers as well as a ton of high-quality recommendations for books and podcasts. Enjoy!
Akshay’s Blog is now Write Software, Well
This blog is about writing as much as it is about software development. After two years, 130 posts, and hundreds of thousands of readers, the blog has outgrown my personal domain and needs a new home. Welcome to “Write Software, Well”.
Base64 Encoding, Explained
Base64 is an elegant way to convert binary data to text, making it easy to store and transport. This article covers the basics of Base64 encoding, including what it is, how it works and why it’s important. It also shows how to encode and decode Base64 data in various programming languages.
Understanding the Instrumentation API in Rails
The Instrumentation API in ActiveSupport serves a dual purpose. You can use it to implement the observer (pub-sub) pattern, as well as benchmark how long it took to execute some action. In this post, we’ll learn almost everything you need to know about the Rails Instrumentation API.
Length, Size, and Count in Ruby and Rails: When to Use Which?
You can use the length, size, and count methods to find the number of elements in a collection. This post explores the difference between these methods and explains how you should choose which method to use according to the needs of your application.
Interview with Miles Woodroffe, former Global CTO of Cookpad
Miles Woodroffe is a veteran Ruby & Rails developer who served as a Global CTO at Cookpad for many years and represents the company as a founding board member at the Rails Foundation. I recently had the pleasure to interview Miles, and he graciously provided very thoughtful and interesting answers.
The Difference Between nil?, empty?, and blank? in Ruby
In Ruby, you can use nil? method to check if the object is nil. However, Ruby also provides empty? and there’s a blank? method in Rails. For a Ruby (or Rails) newbie, it can get quite confusing, it certainly did for me. This post explains which method to use when. Hope it simplifies things a little.
Refactoring: Improving the Design of Existing Code (My Notes and Highlights)
I recently re-read Martin Fowler’s excellent book on refactoring. It’s about improving the design and quality of your code in small steps, without changing external behavior. The book contains detailed descriptions of refactorings, with motivation, mechanics, and an example for each. A must-read.
What Happens When You Run Rails dev:cache Command?
You can enable caching in development mode by running the `rails dev:cache` command in terminal. Ever wondered what that command does, and how exactly does it tell Rails to start caching stuff in your application? Let’s take a peek behind the curtain to see exactly what’s going on.
How to Access a Ruby Hash with both String and Symbol Keys
Sometimes, you receive a Hash key as a method parameter or via user input, and you want to make the Hash understand that key as-is, without worrying if the key is a string or a symbol. ActiveSupport’s `HashWithIndifferentAccess` class lets you accomplish this in a convenient way.
How to Debug and Step-Through Rails Codebase
Do you want to read the Rails source code for a deeper understanding of the framework, but feel intimidated by the sheer size of the codebase, or don’t know where to start? Start with a specific feature, insert a breakpoint, and step through the method line-by-line. This article shows how.
The Complete Guide to Working With Cookies in Rails
This post covers almost everything you need to know about HTTP cookies in the context of Rails. We’ll explore what a cookie is, why we need it, how to set & get a cookie, how to restrict cookies to a particular domain/path, prevent JavaScript access, how to sign & encrypt cookies, and much more.
Rails Middleware: (Almost) Everything You Need to Know
In this post, we’ll learn almost everything about Rails middleware: what it is, why we need it, how it works, and why it’s so important. We’ll also learn how to create and test custom middleware in a Rails app. Finally, we’ll extract logging functionality in its own middleware in a simple web app.
Let’s Read the Turbo Source: What Happens When You Click a Link?
Reading the source code is one of the best ways to learn how a feature, framework, or a program works. In this post, we’ll explore the source code of Hotwire’s Turbo library to understand exactly what happens when you click a link. I hope you’ll appreciate Turbo much more after this deep dive.
Let’s Implement the Map Method from First Principles
Those new to functional programming often wonder when to use higher-order functions (or blocks/procs/lambdas in Ruby). I did, too. In this post, we’ll implement the map method from scratch, in turn gaining an intuitive understanding of higher-order functions and when to use them.
Rails Database Migrations Cheatsheet
The database schema evolves continuously. Rails migrations is a powerful and flexible way to update the schema without dropping and re-creating the database. However, all this power and flexibility can be overwhelming. Here’s a handy cheatsheet for most common migration operations.
How to Check if a Variable is Defined in Ruby with defined? Keyword
Ruby’s defined? keyword is an elegant, compact and fun way to check if a variable is defined or not and also to cache expensive operations. However, many gotchas await the new programmer. Now that I’ve had a few opportunities to work with it, here’s my shot at sparing you some of the confusion.
Practical Stimulus: Building a Counter Component
In this article, we will build a counter component using the Stimulus JavaScript library. This simple example will demonstrate a bunch of useful features of Stimulus such as managing state, handling events, and targeting DOM elements.
Ruby’s Hash is a Swiss-Army Knife
A Hash is a built-in data structure in Ruby that maps values to keys and has a constant-time O(1) lookup. This article shows the capabilities of this simple, but equally powerful tool. We’ll start with the basics but also cover some obscure but equally useful features of hash.
Abbrev: A Hidden Ruby Gem
The Abbrev module in the Ruby standard library helps you find out all the possible and unique abbreviations for one or more strings. In this post, we’ll learn how it works along with a practical example. We’ll also take a peek behind the scenes to see how it’s implemented.
Using Zeitwerk Outside Rails
Did you know you can use Zeitwerk outside Rails? This article shows how to use the Zeitwerk gem to autoload classes and modules in a Ruby app that’s not using Rails. We’ll also learn how Rails configures Zeitwerk internally and introduce the concept of models in our no-rails Ruby web application.
How to Implement Content Security Policy in Rails
This article shows how to implement content security policy in your Rails applications to protect against cross-site scripting (XSS) vulnerability. We’ll also learn how you can report CSP violations without enforcing the policy and make exceptions for inline scripts with nonce attributes.
You Don’t Need Rails to Start Using Hotwire
Although Hotwire is closely tied to Ruby on Rails, you might be surprised to know that you don’t really need Rails to learn, play, and experiment with Hotwire. In this article, we’ll build a simple static site that uses Turbo Drive + Frames to make it responsive and use Streams to make it dynamic.
Content Security Policy (CSP): Everything You Should Know
This is a comprehensive guide to Content Security Policy (CSP). If you build websites for a living, CSP is an important concept to know, understand, and implement to protect your users from Cross-Site Scripting (XSS) Injection attacks. This post covers (almost) everything you need to know about CSP.
Logging in Ruby: (Almost) Everything You Need to Know
Like backups, logging is one of those topics that seems unnecessary until something goes wrong! It’s very frustrating to fix a bug that’s only reproducible in production without having any logs to help you debug it. This post covers the basics of logging in Ruby and adds logging to our no-rails app.
How to Dynamically Create Instance Variables in Ruby
This post shows one way to dynamically initialize multiple instance variables in a Ruby class using metaprogramming. If you need to pass multiple, separate pieces of data to a constructor (and cannot refactor the code for some reason), it’s a pretty good technique to reduce all the repetitive code.
A Brief Introduction to Rails Initializers: Why, What, and How
At first glance, Rails initializers seem complex, but they’re solving a simple, but important problem: run some code after framework and gems are loaded, to initialize the application. This post covers the basics of initializers, including what they are, how they work, and how Rails implements them.
How to Render SVG Icons in Ruby on Rails
This post shows how I render SVG icons in my Ruby on Rails applications. Instead of littering your HTML with complicated SVG tags, keep them tucked away in a folder as an ERB partial, and use a Rails helper to insert it in your views. Result: reusable, customizable icons and readable HTML.
How to Implement Rails-like Views in Ruby
In this article, we will learn ‘one’ way to implement the controller-to-view data handoff using instance variables, just like Rails, and following the same conventions as Rails. Although it’s a highly simplified implementation to keep things simple, I hope you’ll find it fun and learn something new.
Implementing Rails-like Controllers in a No-Rails App
In its essence, a controller class in Rails is a coordinator. It accepts the incoming HTTP request and builds the data required by the view using the domain models. This post shows a highly simplified implementation of the controller pattern for a better understanding of Rails controllers.
Understanding the Concept of Binding in Ruby
Binding is an elegant way to access the current scope (variables, methods, and self) in Ruby. Typically, you use it for building view templates and executing strings of Ruby code. The Ruby REPL also makes abundant use of binding. In this post, we’ll learn what binding is and how it works.
Build Your Own Router in Ruby
Have you always wondered what a Router is and how it works? I know I have. In the third article in the series on building a web application in Ruby without Rails, we’ll build our own router to get a deeper understanding and appreciation of the Rails Router.
Let’s Build a Webapp in Ruby without Rails: Serve Static Files and Render Dynamic Views
This is the second article in the series where we build a simple, yet complete web app in plain Ruby, without using Rails to better understand how Rails works. In this article, we’ll learn how to serve static files and use the ERB gem to render dynamic views. All in plain Ruby, without using Rails.
Let’s Build a Web Application in Ruby without Rails
Rails is great for building web apps. But it can be quite overwhelming if you don’t know how web applications work. In this series of articles, we’ll build a simple but complete app in plain Ruby without Rails, to get a deeper understanding and appreciation of everything Rails does for us.
How to Split a List into N Equal Parts in Ruby (and Rails)
This article shows you can split (or chunk) a list of items into n-equally sized parts using the `each_slice` method in Ruby and `in_groups_of` method in Rails.
Blocks, Procs, and Lambdas: A Beginner’s Guide to Closures and Anonymous Functions in Ruby
Closures and anonymous functions are very useful concepts, especially in functional programming. Ruby makes working with them a pleasure via its flavors like blocks, procs, and lambdas. This post provides an in-depth tutorial and shows the subtle differences between them.
How Module Autoloading Works in Ruby and Rails
Autoloading allows you to speed up the initialization of your library by lazily loading the code only when you need it. This post explains how the autoload method works in Ruby and how Rails overrides this method to provide its own implementation that follows the Rails naming conventions.
Practical Stimulus: How to Toggle CSS Classes
This second article in the ‘Stimulus in Practice’ series shows how you can work with HTML classes using Stimulus. Specifically, we’ll learn how to toggle classes on an element. This is useful when you want to show or hide certain elements or update the design in response to user interaction.
Practical Stimulus: Capture User Input
Stimulus is a JavaScript library that works really well with the HTML-over-the-wire approach of building web applications. In this series of articles, we’ll learn how to accomplish common front-end tasks using Stimulus. This post shows how to capture user input and display it on the screen.
Unix: A History and a Memoir
I recently read Brian Kernighan’s Unix: A History and a Memoir. If his name sounds familiar, Brian is also the author of The C Programming Language, along with Dennis Ritchie, the creator of C.
How to Create a Form with Multiple Submit Buttons to Different URL Endpoints
The formaction attribute on the button elements let you submit the form to a different URL endpoint. Additionally, you can use formmethod attribute to override the parent form’s method.
Generating Secure Tokens on Your ActiveRecord Models
You must have used the `has_secure_password` macro in Rails. Did you know Rails also provides a `has_secure_token` macro to generate unique tokens on your models? In this article, we’ll learn how it works and we’ll also see how Rails implements it behind the scenes.
A Beginner’s Guide to Rails Parameters
Parameters in Rails let you access data sent by the browser, either in the URL or via form submission. In this article, we’ll cover the basics of parameters, including what they are, how they work, and why they’re important. We’ll also learn how you can pass parameters when redirecting a request.
How to Render Markdown Views in Rails
This article shows how to create and render markdown views in Rails. This is useful if you have a few static marketing pages in your web application that you’d like to save and edit as markdown along with the rest of your code files.
Concerns in Rails: Everything You Need to Know
Concerns are an important concept in Rails that can be confusing to understand for those new to Rails as well as seasoned practitioners. This post explains what concerns are, how they work, and how & when you should use them to simplify your code, with practical, real-world examples.
How to Create Custom Flash Types in Rails
While reading the Rails codebase last week, I came across a useful method that lets you create custom flash types. In this post, we’ll learn how to use it and also how it’s implemented behind the scenes. In the process, we’ll also learn a few metaprogramming tricks in Ruby.
Inline Routes in Rails
If you want to quickly try out some Rails feature or code in the browser without spinning up a whole new controller and a view, simply map the incoming request to a lambda Rack endpoint, i.e. a lambda that returns the status, headers, and response body.
Simplifying My Blogging Workflow with Ruby
This is the 100th post on this blog 🎉 I wanted to share how a simple Ruby script simplified my blogging workflow and dramatically increased the number of posts I write on my various blogs.
Did You Know that You Can Catch and Throw Stuff in Ruby?
Unlike traditional programming languages, Ruby’s throw and catch are not used to raise and catch exceptions. Instead, they let you escape from deeply nested control flows. This post shows how `throw-catch` works in Ruby with practical, real-world examples, including their usage by the Warden gem.
Polymorphic Associations in Rails: Why, What, and How
Polymorphic associations in Rails allow a single model to belong to multiple models. This article covers them in-depth. We’ll start with understanding the concept of polymorphism, learn what a polymorphic association is, why we need them, how they work, and how to use them in your Rails application.
Various Ways to Run Shell Commands in Ruby
Ruby provides multiple ways to conveniently execute external processes from the code. In this article, we’ll learn all the ways you can run shell commands in Ruby and also consider various circumstances under which you’d choose one over the other.
Ruby’s Switch Statement is More Flexible Than You Thought
Ruby’s switch statement is very versatile and flexible, especially due to the dynamic nature of Ruby. In this post, we’ll see how you can use it in various ways. We’ll also learn why it works the way it works. Hint: it uses the `===` operator (method) under the hood.
Can You Spot the Error?
I recently encountered this error and in the process of debugging, learned some useful stuff about `self` and how assignment works in Ruby. See if you can figure it out yourself. Can you spot the error in this simple Ruby snippet?
A List of Books to Learn Programming with Ruby and Rails
This post provides a curated list of books to learn to code in Ruby and build web applications with Rails. It also gives a step-by-step path you can follow to learn enough before moving to the next step. If you ever wanted to learn to program but didn’t know where to start, this post is for you.
How to Access Hash Values with Methods Using OrderedOptions
Have you ever wanted to create a hash where you could access the values like methods on an object? The OrderedOptions class in Rails lets you do just that. This post shows you how. We’ll also explore how Rails implements this feature using Ruby’s metaprogramming features.
The Definitive Guide to Rack for Rails Developers
The word Rack actually refers to two things: a protocol and a gem. This article explains pretty much everything you need to know about Rack as a Rails developer. We will start by understanding the problem Rack solves and move to more advanced concepts like middleware and the Rack DSL.
How to Access Rails Models in a Rake Task
This article shows how you can access your application models inside rake tasks by adding the `environment` task as a dependency. We’ll also go one level deeper and learn exactly how it works behind the scenes.
Readonly Attributes in Rails
In this article, we’ll learn how to mark certain attributes as readonly on your active record models, to prevent them from any future updates after the record is created and saved to the database. We’ll also learn how Rails implements this feature behind the scenes.
Sessions in Rails: Everything You Need to Know
In this post, we’ll learn about Rails sessions, including what is a session, why we need them, and why they’re so important. I’ll also take you behind the scenes and show you how Rails implements sessions and where the `session` method actually comes from. Hint: it’s not in the Rails codebase.
Understanding the Attribute Assignment API in Rails
In this post, we will explore the `AttributeAssignment` module in Rails, which allows you to set an object’s attributes by passing in a hash, a feature commonly used by Active Record models. We’ll also learn a little metaprogramming along the way.
Progressive Application Development with Hotwire
This is the day when you fall in love with Hotwire. We’re going to build a simple counter. But we’re not going to build it once and be done with it. Instead, we’ll build and progressively enhance it with all three frameworks in Hotwire: Turbo Drive, Turbo Frames, and Turbo Streams.
Configuring Rails Environments
Despite its strong opinions and powerful conventions, Rails is a highly flexible and configurable framework. If you don’t like something, there’s almost certainly a way to change it. This article provides a brief overview of configuring Rails applications and environments.
Turbo Streams: How They Work and Differ From Turbo Frames
No, you don’t need WebSockets to use Turbo Streams. You can simply use them to deliver multiple page updates with a single HTML response. This article teaches the basics of Turbo Streams to build a SPA without writing a single line of JavaScript. No Rails needed, either!
A Brief Introduction to Hotwire
Hotwire, which stands for HTML Over the Wire, provides a different way to build modern web applications without using too much JavaScript. This article provides a quick introduction to Hotwire and its component frameworks, such as Turbo Drive, Frames, and Streams.
How Rails Authenticity Tokens Protect Against CSRF Vulnerability
Rails protects your web application from CSRF attack by including an authenticity token in the HTML forms. This token is also stored in the user’s session. Upon receiving a request, Rails compares these two tokens to decide if the request is verified.
Cross-Site Request Forgery (CSRF) Attack: What It Is, How It Works, and How to Prevent It
CSRF vulnerability tricks authenticated users of an application to perform a dangerous activity on that application, simply by clicking a link. This post explains how CSRF works with a practical example, and shows how to protect against it, both as a user and a developer building web applications.
Docked Rails: Setup a Ruby on Rails Application on Docker 🐳
Setting up a new Ruby on Rails application with all the dependencies doesn’t have to be complicated. Docked is a new command line tool that simplifies the process of creating a new Rails app using Docker.
Nested Modules in Ruby
Ruby provides two different ways to define nested modules. This post explains the difference between them and how to decide which one to use. It also explains the `Module.nesting` method which returns the list of modules nested when called.
The Difference Between load, autoload, require, and require_relative in Ruby 📖
Loading external files can get tricky in Ruby, but it doesn’t have to be. This post explains the usage of Ruby’s load, require, and require_relative methods, and when to use each.
Open GitHub Repositories in VS Code In-Browser
GitHub allows you to open any repository in an in-browser VS Code by just pressing the `.` key on your keyboard.
Method Shorthand in Ruby
Ruby (3.0 and up) provides a shorthand syntax for one-line methods, similar to computed properties in C#.
Array Inquiry in Rails
The ArrayInquirer class provided by the Active Support framework in Rails provides a readable way to check the contents of an array. This post explores how you can implement this using metaprogramming in Ruby.
How to Check If Value Exists in an Array in Ruby (and Rails)
In this post, we’ll learn two different ways to check if a value is included in an Array.
Tracking TODO and FIXME Comments with Rails Notes Command
This post shows how you can use the notes command in Rails to search through your codebase for comments starting with a specific keyword. By default, it searches the codebase for FIXME, OPTIMIZE, and TODO comments, but you can also configure it to use custom keywords.

That's a wrap. I hope you've found my blog helpful and you've learned something new from it.

As always, if you have any questions or feedback, didn't understand something, or found a mistake, please leave a comment below or send me an email. I reply to all emails I get from developers, and I look forward to hearing from you.

If you'd like to receive future articles directly in your email, please subscribe to my blog. If you're already a subscriber, thank you.