In the previous part of this series about validating data at the boundary of an Elixir application, we covered a few general programming tactics to try and reject invalid and unexpected data in our software. Continuing with that subject, we'll now explore how two libraries, namely Ecto and NimbleOptions, can further assist us. Let's get started!
Deno and Bun are two JavaScript runtime newcomers that aim to undermine Node.js. These alternatives have gained popularity for their innovative approach to server-side development with JavaScript. But the real question is: what do they bring to the table compared to Node.js? In this post, you'll learn what Deno and Bun are, what they offer, and how they address some long-standing drawbacks in Node.js. We'll shed light on specific use cases where Deno and Bun excel.
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.
