Systems | Development | Analytics | API | Testing

Ruby on Rails 7.1: Partial Strict Locals and Their Gotchas

Rails partials have been around for years, but they can be clunky since they're just ERB snippets without a backing object structure. Recently, libraries like ViewComponent and Phlex have tried to improve the view layer by adding more semantic structure to the templates. These are great libraries and I personally reach for ViewComponent on almost every project I work on. That said, I still feel the humble Rails partial still works great for many use cases.

Scaling Your Phoenix App in Elixir with FLAME

When you build an app, you'll often find that certain tasks do not require user interaction and are better performed in the background. Elixir provides excellent primitives, such as Task.async, to offload these tasks from the main user pipeline. Additionally, libraries like Oban offer more control over background tasks when needed. There's also FLAME, which the core Phoenix team is developing to offer a scalable solution for offloading intensive tasks to remote machines.

How to Handle Errors in Next.js for Node With the App Router

Error handling in Next.js is critical to providing a seamless experience to your users even when things go wrong. Without proper error management, users may get confused about what has happened and even leave your site. To avoid that, you must ensure that they receive informative feedback about errors and provide a way to recover from them. In this article, you'll see: Let's jump right in!

Build a One-Product Shop With the Python Django Framework and Htmx

This is the first of a two-part series using Django, htmx, and Stripe to create a one-product e-commerce website. In this part, we'll start our Django project and integrate it with htmx. In the second part, we'll handle the orders with Stripe. Let's get going!

Squash Your Ruby and Rails Bugs Faster

A bug in software can be disruptive, elusive, maddening, and invasive. Indeed, a developer often needs the tenacity of Edison to find and fix an issue. But grit isn't the only asset a developer requires. One also needs information to debug code: What are the symptoms and effects of the issue? What is its frequency? Pervasiveness? Provenance? The evidence and artifacts of a bug — a core dump, stack trace, log, or test case — are invaluable.

Monitor Node.js AMQP Brokers with AppSignal

AppSignal's Node.js package now offers out-of-the-box support for the AMQPlib package, enabling monitoring of inbound and outbound messages from popular Advanced Message Queuing Protocol (AMQP) brokers like RabbitMQ. In this article, we'll show you how to set up and use AppSignal to monitor your AMQP broker's performance.

LiveState for Elixir: An Overview and How to Build Embeddable Web Apps

If you have programmed with Phoenix, you already know what a delight it can be to work with LiveView. LiveView simplifies your development process by moving all state management to the server. This reduces the complexity of coordinating states between the client and server. LiveState aims to extend a LiveView-like development flow to embeddable web apps. But before we delve deeper into LiveState, let’s first understand what embeddable web apps are.

An Introduction to Unit Testing in Node.js

Unit tests are essential to verify the behavior of small code units in a Node.js application. This leads to clearer design, fewer bugs, and better adherence to business requirements. That's why Test-Driven Development (TDD) and Behavior-Driven Development (BDD) have become so popular in the backend development community. In this tutorial, we'll dive into unit testing and understand why it's needed in your backend.

An Introduction to HTTP Caching in Ruby On Rails

It's 2024, and the HyperText Transfer Protocol (HTTP) is 35 years old. The fact that the vast majority of web traffic still relies on this simple, stateless form of communication is a marvel in itself. A first set of content retrieval optimizations were added to the protocol when v1.0 was published in 1996. These include the infamous caching instructions (aka headers) that the client and server use to negotiate whether content needs refreshing.