In the second post of our series covering LiteStack (an alternative way to build Rails applications entirely based on SQLite), we'll explore the database's concepts of flexible typing and type affinity. We'll not only discover how SQLite's data handling differs from other SQL databases, but also how we efficiently process and store binary data, like images, directly in a database column. Note: LiteDB is essentially SQLite, but fine-tuned for usage in Rails.

Node.js v21, the latest Node update, is now available as a stable release. It supersedes v20 in the'Current' release line, which has been promoted to the long-term support (LTS) channel as of 24 October. This new version stabilizes the fetch and WebStreams API, adds a built-in WebSocket client, improves support for ES modules, and brings some notable performance improvements (as well as a customary update of Node.js dependencies such as V8).

Elixir excels at building scalable and maintainable applications. However, sometimes Elixir is not the best language to tackle specific tasks, and it can fall short in some areas, like direct system interaction. Fortunately, Elixir offers NIFs (Native Implemented Functions): a path for integrating with other languages to improve these gaps.

In the first part of this series, we built the asynchronous components of a much larger solution. Today, we will build the API interface that can be consumed in real-time.

In part one of this series, we looked at some basic usages of Action Policy. Now we'll leverage Action Policy for more advanced authorization use cases. First up, let's explore applying pre-checks.

Ruby is an expressive language. This is no accident; Matz very consciously designed Ruby as an intuitive language to more or less read like English. It's safe to say that he succeeded. Methods are named very carefully, and do what they say they do; they also tend to have inverse methods which do the opposite. In this post, we'll look at why expressive code is important and its impact on your productivity as a developer. Then, we'll explore how to best use some of Ruby's methods. Let's get started!

In this first part of a two-part series, we'll explore how to avoid bad data and validate data at the boundary of a Phoenix application. We'll use a few techniques to ensure that bad data doesn't degrade our application. In part two, we'll specifically focus on leveraging Ecto under the hood to cast data. Let's dive in!

To keep your app secure, you need to control who and what can access it. Access control can be categorized into authentication — "who" to allow — and authorization — "what" they can access. Authentication is a subject for another day, but when it comes to user authorization, you generally have two ways to go about it: using a role-based or resource-based strategy. In this two-part series, we'll take a deep dive into using the Action Policy gem for a Ruby on Rails blog application.

Complex functionality can take a while to load. Users, in general, don't like to wait, so solutions must evolve. If you are already familiar with async/await in JavaScript, think of await as the place where blocking logically occurs. This forces the algorithm to wait, and technically, it's still synchronous code. Step functions allow long-running processes to run in the background asynchronously, so the logic does not get blocked and force people to wait.

In this article, we'll show how you can use Elixir's profile.eprof mix task to evaluate and improve code performance in your Elixir application. You'll see how we used the profiling mix task to lower reductions in our instrument/3 function and custom instrumentation functionality, both key parts of our Elixir integration.