🐥 YellowDuck.be

🔗 Designing AI features that actually help users

2026-04-04T13:00:00Z

Many AI features often misfire due to poor interface design rather than flawed models. By maintaining the original workflow structure, AI can effectively translate user intent into structured data that enhances functionality without overwhelming users.

Traditional filtering interfaces can become complex and unwieldy, making it hard for users to articulate their needs. This approach proposes an intuitive AI-driven intent layer that simplifies user interactions by converting natural language into understandable filter parameters, leading to a more efficient and user-friendly experience.

Continue reading on www.mimiquate.com

#reading-list #frontend #best-practice #ai

🔗 Using ClickHouse as a webhook endpoint with HMAC verification

2026-04-04T08:00:00Z

One of the standout features in ClickHouse 25.12 is the HMAC function, which allows for message authentication with a shared key. This functionality enhances ClickHouse's ability to act as a webhook endpoint by enabling verification of incoming requests, thereby filtering out unauthorized sources.

The setup involves three primary components: a staging table initiated with the MergeTree engine, a materialized view for data validation, and a logs table to store successful entries. This method, paired with ClickHouse's architecture, ensures that only validated data is recorded, while invalid requests are rejected based on signature mismatches.

Continue reading on clickhouse.com

#reading-list #database #best-practice #http

🔗 Re-Implementing the Google Reader API in 2025

2026-04-03T17:00:00Z

In 2025, a post details the implementation of a Google Reader API-compatible service using Elixir. Despite challenges with the original API's lack of documentation, a baseline features implementation emerges, including logging in, fetching subscriptions, and managing feed item statuses.

The project illustrates the complexity of working with reverse-engineered specifications and feeds, emphasizing the need for compatibility with evolving RSS clients. It describes essential concepts and endpoints while acknowledging that the API's intricacies make achieving a complete implementation challenging yet feasible for practical use.

Continue reading on www.davd.io

#reading-list #development #tools #elixir

🔗 Thinking Elixir Podcast 297: JavaScript Joins the BEAM?

2026-04-03T13:00:00Z

News includes Quickbeam bringing a full JS runtime into the BEAM, Elixir’s type system inspiring Python’s Ruff, LiveView Debugger v0.7, Oban v2.21, and more!

Continue reading on podcast.thinkingelixir.com

#reading-list #elixir #phoenix

🔗 AI should help us produce better code

2026-04-03T08:00:00Z

Many developers fear that AI tools will compromise code quality, producing hastily written, flawed code. Instead of accepting poor output, teams should address flaws directly and choose to improve their code quality.

Technical debt often arises from trade-offs during development, and avoiding it in the first place is ideal. Coding agents, like Gemini Jules and OpenAI Codex, can effectively handle refactoring tasks and enhance the development process without disruption, ensuring higher quality outputs with minimal cost.

Continue reading on simonwillison.net

#reading-list #development #best-practice #ai

🐥 Installing Claude Code on macOS with Homebrew (and getting the latest version)

2026-04-02T17:00:00Z

If you’re installing Claude Code on macOS using Homebrew, the official instruction currently suggests:

brew install claude-code

While this works, it installs the latest stable version, not the latest available version. Depending on your use case, that can leave you behind on features and fixes.

Install the latest version

To install the most recent release, you should explicitly use:

brew install claude-code@latest

This ensures you’re running the newest version instead of the lagging stable cask.

Fix an existing installation

If you already installed claude-code using the default command, you’ll need to replace it:

brew uninstall claude-code && brew install claude-code@latest

That removes the stable version and installs the latest one cleanly.

Why this matters

Homebrew distinguishes between:

Stable casks → default installs (claude-code)
Versioned or alternative casks → explicit installs (claude-code@latest)

In this case, the naming is a bit misleading because @latest is not the default. This has already caused confusion in the community and is being discussed upstream.

More context

Issue discussion: https://github.com/anthropics/claude-code/issues/42176
Homebrew PR: https://github.com/Homebrew/homebrew-cask/pull/255221

Takeaway

If you want the newest Claude Code features and fixes, don’t rely on the default install. Use:

brew install claude-code@latest

and you’ll avoid running an outdated version without realizing it.

#tools #announcement #mac

🔗 Why use static closures?

2026-04-02T13:00:00Z

In PHP, static closures are significant since they prevent unintended references to the object, enhancing memory management. By using the static keyword, developers can ensure closures do not bind to $this, allowing for earlier memory release and avoidance of memory leaks.

The upcoming PHP 8.6 update aims to automate this process with inferred static closures, optimizing performance and memory usage. This change will streamline code, making it safer by default and reducing the risk of accidental captures, further promoting efficient memory management in PHP development.

Continue reading on f2r.github.io

#reading-list #development #php #best-practice

🔗 Type systems are leaky abstractions: the case of Map.take!/2

2026-04-02T08:00:00Z

Adding a type system to Elixir showcases the limits of expressive programming languages. This article examines the proposal of Map.take!/2 and its potential to enhance type safety by raising errors for missing keys in maps.

The function aims to align with Elixir's dynamic nature while addressing type correctness. This post highlights challenges in achieving precise type signatures and suggests that utilizing macros may provide a viable solution to ensure static key validation without exposing the type system to unnecessary complexity.

Continue reading on dashbit.co

#reading-list #pattern #best-practice #elixir

🔗 How do you know if you’re a good leader?

2026-04-01T17:00:00Z

In this article, self-reflection is highlighted as a crucial aspect of effective leadership. Drawing inspiration from Abraham Lincoln's introspective writings, it emphasizes that good leaders embrace self-doubt, manage uncertainty, and seek honest feedback from multiple sources.

Effective leadership isn’t about perfection but recognizing and addressing flaws. Leaders should engage in honest self-evaluation, understanding that their effectiveness is perceived through the experiences of others, not solely their self-assessment.

Continue reading on mikefisher.substack.com

#reading-list #best-practice

🔗 Good software knows when to stop

2026-04-01T13:00:00Z

Good software excels by understanding its core purpose and knowing when to stop evolving. This article highlights that effective tools avoid unnecessary complexity and focus on what truly serves users' needs.

It emphasizes lessons from notable figures in software development, advocating for constraints as advantages. By prioritizing essential features and understanding underlying problems, developers can create better solutions and ensure their software remains impactful without overstretching.

Continue reading on ogirardot.writizzy.com

#reading-list #development #pattern #best-practice

🔗 Using systemd units for Laravel cronjobs and background processes

2026-04-01T08:00:00Z

Most Laravel applications require background processes on Linux servers. This article explains how to use systemd for tasks like cronjobs or queue workers, instead of relying on Supervisor.

Using systemd offers centralized logging, dependency management, and resource limitation benefits. The article details creating service and timer units for running Laravel processes with corresponding examples and commands for verification.

Continue reading on command-g.nl

#reading-list #laravel #best-practice #devops #linux

🐥 Taming scrollbars in a Phoenix app

2026-03-31T17:00:00Z

One of those tiny UI details that quietly annoys users more than you'd expect: scrollbars that flash in and out of existence, causing the page layout to jump around. This week I finally cleaned it up in my Phoenix app and the fix was surprisingly elegant.

The problem

The original root.html.heex had this on the element:

<html lang="en" class="[scrollbar-gutter:stable]">

scrollbar-gutter: stable is a CSS property that reserves space for the scrollbar even when it isn't needed — the idea being to prevent layout shifts when content height changes. It's a reasonable approach, but it has a side effect: on macOS with "Show scroll bars: Always", you end up with a permanent empty gutter on pages that don't scroll. On Windows, where scrollbars are visible by default, the gutter is always there. Depending on your layout, that reserved space can look odd.

The solution

I removed the Tailwind utility class from the tag and instead reached for a small CSS snippet:

/* Only show scrollbars when content actually overflows */
* {
  scrollbar-width: thin;
  scrollbar-color: transparent transparent;
}

*:hover {
  scrollbar-color: rgba(0, 0, 0, 0.2) transparent;
}

What this does:

scrollbar-width: thin — uses the browser's thin scrollbar variant, which is less visually heavy than the default.
scrollbar-color: transparent transparent — hides the scrollbar thumb and track by making them fully transparent. The scrollbar doesn't disappear from the DOM; it just becomes invisible when you're not interacting with the element.
*:hover { scrollbar-color: rgba(0,0,0,0.2) transparent } — fades the scrollbar thumb in (as a subtle translucent grey) only when the user hovers over the element. This gives a clean overlay-style scrollbar feel, similar to what macOS does natively.

Why this feels better

The end result is a UI that looks clean and uncluttered at rest, but still gives users a clear scrollbar affordance the moment they move their cursor over a scrollable area. No layout jump, no reserved gutter space, and no permanently visible chrome competing for attention.

It's a two-file change — one CSS block and the removal of a single Tailwind class — but the visual impact is noticeable, especially on pages with sidebars or nested scrollable containers.

Browser support

scrollbar-width and scrollbar-color are part of the CSS Scrollbars Specification and have solid support in Firefox and Chromium-based browsers. Safari added support in version 18.2. For older Safari versions the scrollbar will just render with its default appearance — a perfectly acceptable fallback.

Small change, cleaner app. Sometimes that's all it takes.

#css #elixir #phoenix #html

🔗 Weaving stories with cascading workflows

2026-03-31T13:00:00Z

The newly announced Pro v1.6 RC introduces innovative workflow features, revolutionizing how tasks are coordinated. With its user-friendly design, building workflows requires no specialized knowledge, fostering creativity and spontaneity.

The article showcases the creation of the "Fire Saga" workflow, which generates children's stories through generative AI. By employing Oban Workflows, it seamlessly manages task dependencies, making the storytelling process automated and efficient while producing delightful results.

Continue reading on oban.pro

#reading-list #pattern #elixir #announcement

🔗 Things I miss about Spring Boot after switching to Go

2026-03-31T08:00:00Z

This article compares the advantages of Spring Boot with the simplicity of Go after transitioning from one to the other. It highlights Spring Boot’s extensive features like dependency injection, built-in validations, and a mature ecosystem which greatly aid backend development, whereas Go’s minimalism promotes explicit code and lower resource usage, making deployment easier and faster.

The discussion emphasizes that Spring Boot offers solid foundational tools for complex applications, such as Spring Security and Spring Data, which facilitate quick implementation of essential backend features. Conversely, Go's concurrency model and quick startup times are beneficial for lightweight services and applications, stressing that each technology has its strengths based on the system needs.

Continue reading on sushantdhiman.dev

#reading-list #golang #development #best-practice #java

🐥 A better way: Using mkcert for HTTPS in Phoenix on macOS

2026-03-30T17:00:00Z

In a previous post, I showed how to use mix phx.gen.cert to set up HTTPS in Phoenix development. While that approach works in theory, in practice it's a minefield: OpenSSL 3.x generates PKCS12 bundles that macOS's security command rejects, browsers send cryptic Decode Error alerts, and manually trusting certificates in Keychain Access often has no effect at all.

There's a much better tool for this: mkcert.

What makes mkcert different?

mkcert creates a local Certificate Authority (CA) on your machine and registers it with macOS's system trust store, Firefox, and Chrome in one command. Any certificate you generate from it is automatically trusted — no manual Keychain fiddling required.

Step 1: Install mkcert and register the local CA

brew install mkcert
mkcert -install

The -install step is what makes everything work. It adds mkcert's root CA to your system keychain so all browsers trust it going forward.

Verify it landed:

security find-certificate -c "mkcert"

Step 2: Generate a certificate for localhost

From your Phoenix project root:

mkcert -cert-file priv/cert/selfsigned.pem \
       -key-file priv/cert/selfsigned_key.pem \
       localhost 127.0.0.1 ::1

This generates a certificate valid for localhost, 127.0.0.1, and ::1, signed by your local CA.

Step 3: Configure Phoenix for HTTPS

Update config/dev.exs:

config :your_app, YourAppWeb.Endpoint,
  https: [
    port: 4001,
    cipher_suite: :strong,
    certfile: "priv/cert/selfsigned.pem",
    keyfile: "priv/cert/selfsigned_key.pem"
  ],
  check_origin: false,
  code_reloader: true,
  debug_errors: true

Start your server:

mix phx.server

Visit https://localhost:4001 — no browser warnings, no certificate errors, no Keychain gymnastics.

What about the cert files in version control?

The generated priv/cert/ files are already in .gitignore when using mix phx.gen.cert, and should stay there with mkcert too. Each developer on your team runs mkcert -install and generates their own certificate locally.

Upgrading from the old approach

If you followed the previous post, you can replace the existing cert files in place — the Phoenix config stays the same since you're still pointing at priv/cert/selfsigned.pem and priv/cert/selfsigned_key.pem. Just regenerate them with mkcert and restart your server.

#development #tools #elixir #phoenix #terminal

🔗 A minimalist HTTP library for Go

2026-03-30T13:00:00Z

When migrating API services from TypeScript to Go, the need for a lightweight HTTP framework that integrates with OpenAPI and offers precise middleware control becomes crucial. Zen emerges as a solution, focusing on simplicity and efficiency by utilizing Go's standard library without the bloat of complex dependencies.

The structure of Zen allows for custom middleware execution, ensuring cleaner handlers that are focused solely on business logic. By adopting a schema-first approach for OpenAPI integration, Zen guarantees a rigorous API specification that enhances developer experience while maintaining control over the API contract.

Continue reading on www.unkey.com

#reading-list #golang #development #best-practice #http

🔗 Batch inserts in SQL for large data loads

2026-03-30T08:00:00Z

Large data loads in SQL require efficient insert strategies to enhance performance. Using single row inserts can significantly slow down operations due to overhead from network latency, statement parsing, and transaction commit cycles.

Batching inserts minimizes these issues by reducing the number of statements sent to the database, leading to higher throughput. This article highlights the importance of transaction management, indexing, and how batch processing can optimize data loading strategies.

Continue reading on freedium-mirror.cfd

#reading-list #database #best-practice #sql

🐥 Fixing a race condition in Oban job counting with telemetry

2026-03-29T17:00:00Z

When building a LiveView dashboard that shows how many background jobs are still processing, a subtle race condition can make the count permanently off by one. Here's how I ran into it and how Oban's telemetry system solved it cleanly.

The Setup

The app has an Oban worker — ProcessExternalLinkWorker — that fetches a URL, extracts content, and creates a post. The LiveView index page shows a "X post(s) currently being processed" banner while jobs are in flight.

The job count is a straightforward Oban query:

from(j in Job,
  where: j.state not in ["completed", "discarded"] and j.worker == ^worker
)
|> Repo.aggregate(:count, :id)

The LiveView subscribes to a "posts" PubSub topic and refreshes this count whenever a "post_updated" message arrives. That message is broadcast from inside Posts.create_post/1, which is called from within the worker.

The Bug

Here's the execution sequence that causes the problem:

Oban picks up a job — state transitions to executing
The worker calls ProcessExternalLink.process_url/1
That calls Posts.create_post/1, which broadcasts "post_updated"
The LiveView receives the broadcast and re-queries the job count
The job is still executing — it hasn't returned :ok yet
The count includes this job, showing 1 item "still processing" even though the work is done
The worker returns :ok, Oban marks the job completed — but no one tells the LiveView

The post list refreshes correctly, but the processing counter stays at 1 until the next page load.

Subtracting 1 from the count isn't a fix — with multiple concurrent jobs, you'd need to know exactly how many are in this "just finished broadcasting but not yet completed" state, which is unknowable from the outside.

The Fix: Oban Telemetry

Oban emits telemetry events throughout the job lifecycle. The key one here is [:oban, :job, :stop], which fires after the job state has been updated to completed in the database. There's also [:oban, :job, :exception] for failed jobs.

The fix is to decouple the job count refresh from the "post_updated" broadcast. Instead, attach a telemetry handler that broadcasts a separate "jobs_updated" message when a job finishes:

defmodule MyWebApp.ObanTelemetryHandler do
  require Logger

  def attach do
    :telemetry.detach("oban-job-lifecycle")

    :telemetry.attach_many(
      "oban-job-lifecycle",
      [[:oban, :job, :stop], [:oban, :job, :exception]],
      &__MODULE__.handle_event/4,
      nil
    )
  end

  def handle_event([:oban, :job, event], _measurements, meta, _config) do
    Logger.debug("Oban job #{event}: worker=#{meta[:worker]}")
    Phoenix.PubSub.broadcast(MyWebApp.PubSub, "posts", %{event: "jobs_updated"})
  end
end

Two design decisions worth noting:

detach before attach: Calling attach_many with a handler ID that's already registered raises an ArgumentError. In development, a full server restart re-runs application.ex and would hit this error on the second start. Calling detach first makes attach/0 idempotent at the cost of one no-op call.

No worker filter: An earlier version filtered on the worker name in the handler's pattern match. That's redundant — the Ecto query in the LiveView already scopes the count to the specific worker. Removing the filter keeps the handler simpler and avoids fragility around how Oban formats the worker name in telemetry metadata.

Call attach/0 in application.ex after the supervisor starts:

{:ok, pid} = Supervisor.start_link(children, opts)
MyWebApp.ObanTelemetryHandler.attach()

Then handle the new event in the LiveView, separate from "post_updated":

def handle_info(%{event: "jobs_updated"}, socket) do
  worker = inspect(MyWebApp.Workers.ProcessExternalLinkWorker)

  num_processing =
    from(j in Job,
      where: j.state not in ["completed", "discarded"] and j.worker == ^worker
    )
    |> Repo.aggregate(:count, :id)

  {:noreply, assign(socket, :num_processing, num_processing)}
end

Why This Works

The "post_updated" broadcast still fires mid-job and the post list still refreshes correctly — that part was never broken. But the job count is now only refreshed in response to the telemetry event, which is guaranteed to fire after the state change has been committed. The LiveView queries at the right moment.

It also handles failure correctly. If the worker raises an exception, [:oban, :job, :exception] fires, the LiveView refreshes the count, and any retryable or discarded jobs show up accurately.

Takeaway

When displaying counts or status derived from job state, don't trigger the refresh from within the job itself. The job is still running at that point. Instead, hook into Oban's telemetry events, which fire at well-defined points in the lifecycle after state transitions have been committed.

#development #pattern #database #elixir #phoenix

🔗 Why I stopped using AI code editors

2026-03-29T13:00:00Z

TL;DR: I chose to make using AI a manual action, because I felt the slow loss of competence over time when I relied on it, and I recommend everyone to be cautious with making AI a key part of their workflow.

In late 2022, I used AI tools for the first time, even before the first version of ChatGPT. In 2023, I started using AI-based tools in my development workflow. Initially, I was super impressed with the capabilities of these LLMs. The fact that I could just copy and paste obscure compiler errors along with the C++ source code, and be told where the error is caused felt like magic.

Once GitHub Copilot started becoming more and more powerful, I started using it more and more. I used various other LLM integrations right in my editor. Using AI was part of my workflow.

In late 2024 I removed all LLM integrations from my code editors. I still use LLMs occasionally and I do think AI can be used in a way that is very beneficial for many programmers. So then why don’t I use AI-powered code editing tools?

Continue reading on lucianonooijen.com

#reading-list #development #tools #ai #github

🔗 Your agent framework is just a bad clone of Elixir: concurrency lessons from telecom to AI

2026-03-29T08:00:00Z

Recently, José Valim published "Why Elixir is the Best Language for AI", citing a Tencent study showing Elixir achieved the highest LLM code completion rate across 20 languages. Claude Opus 4 scored 80.3% on Elixir problems versus 74.9% for C#, the next-best performer.

But there's a deeper argument than "LLMs write good Elixir." It's this: the actor model that Erlang introduced in 1986 is the agent model that AI is rediscovering in 2026. Every pattern the Python AI ecosystem is building (isolated state, message passing, supervision hierarchies, fault recovery) already exists in the BEAM virtual machine. And it's been running telecom switches, WhatsApp, and Discord at scale for decades.

I've been building agentic commerce infrastructure at New Generation. Before that, I shipped a full AI stack serving more than 3 million merchants at a unicorn Brazilian fintech. Both systems run on Elixir. Here's why that's not a hipster language choice. It's an architectural inevitability.

A note on terminology: Throughout this post I refer to "the BEAM." BEAM is the virtual machine that runs both Erlang and Elixir code, similar to how the JVM runs both Java and Kotlin. Erlang (1986) created the VM and the concurrency model. Elixir (2012) is a modern language built on top of it with better ergonomics. When I say "BEAM," I mean the runtime and its properties. When I say "Elixir," I mean the language we write.

Continue reading on georgeguimaraes.com

#reading-list #javascript #typescript #python #ai #elixir

🐥 TIL: filtering GitHub PRs that are ready for review and not yours

2026-03-28T18:00:00Z

When reviewing pull requests in GitHub, I often want a clean list of PRs that:

are open
are not drafts
are not created by me

Here’s the filter I use:

sort:updated-desc is:pr is:open -author:username draft:false

What this does

sort:updated-desc → most recently updated PRs first
is:pr → only pull requests
is:open → only open PRs
-author:username → exclude your own PRs
draft:false → exclude draft PRs (only show ready-for-review)

This gives a focused, high-signal list of PRs that are actually actionable.

Bonus: explore more filters

GitHub’s search syntax is surprisingly powerful. You can filter by labels, review status, checks, branches, and more.

Check out the full reference here: https://docs.github.com/en/search-github/searching-on-github/searching-issues-and-pull-requests

A few useful additions:

review-requested:@me → PRs requesting your review
status:success → only PRs with passing checks
label:bug → filter by label
-is:merged → exclude merged PRs

Once you start combining these, you can build very tailored review dashboards directly in GitHub.

#development #github

🔗 Easily connecting to BEAM nodes in Kubernetes with kubectl-beam

2026-03-28T14:00:00Z

A kubectl plugin that makes connecting to Erlang and Elixir nodes running in Kubernetes pods as easy as running a single command---with full TTY support and Observer GUI.

Debugging BEAM applications in Kubernetes has always been more painful than it should be. You know the drill: your Phoenix app is misbehaving in production, you need to inspect some process state, maybe run a few commands in an IEx shell, or fire up Observer to see what’s going on. Simple enough on your local machine, right? But in Kubernetes, you end up manually port-forwarding EPMD, figuring out the dynamic distribution port, wrestling with DNS resolution, and praying your terminal doesn’t get mangled in the process.

I’ve done this dance too many times—enough to finally build something that handles all the tedious bits automatically. That’s why I created kubectl-beam, a kubectl plugin that connects you to BEAM nodes running in Kubernetes pods with a single command.

Continue reading on dairon.org

#reading-list #elixir #phoenix #devops #terminal #kubernetes

🔗 Nobody gets promoted for simplicity

2026-03-28T09:00:00Z

“Simplicity is a great virtue, but it requires hard work to achieve and education to appreciate. And to make matters worse, complexity sells better.”
— Edsger Dijkstra

I think there’s something quietly screwing up a lot of engineering teams. In interviews, in promotion packets, in design reviews: the engineer who overbuilds gets a compelling narrative, but the one who ships the simplest thing that works gets… nothing.

This isn’t intentional, of course. Nobody sits down and says, “let’s make sure the people who over-engineer things get promoted!” But that’s what can happen (and it has been, over and over again) when companies evaluate work incorrectly.

Continue reading on terriblesoftware.org

#reading-list #development

🐥 Enforcing polymorphic integrity in PostgreSQL with num_nonnulls

2026-03-27T18:00:00Z

Polymorphic associations are common when a single table can reference multiple other tables. A typical implementation is one table with multiple nullable foreign keys:

CREATE TABLE my_poly_assocs (
  id bigserial PRIMARY KEY,
  assoc_a_id bigint REFERENCES assoc_a(id),
  assoc_b_id bigint REFERENCES assoc_b(id),
  assoc_c_id bigint REFERENCES assoc_c(id)
);

The intent is simple: each row should reference exactly one of these associations. But the database won’t enforce that automatically. Without extra constraints, you can end up with:

No association set (all NULL)
Multiple associations set (invalid state)

PostgreSQL has a clean solution for this.

The `num_nonnulls` function

PostgreSQL provides a built-in function called num_nonnulls. It returns the number of arguments that are not NULL.

That makes it perfect for enforcing “exactly one” semantics:

ALTER TABLE my_poly_assocs
ADD CONSTRAINT exactly_one_assoc_referenced
CHECK (num_nonnulls(assoc_a_id, assoc_b_id, assoc_c_id) = 1);

This constraint guarantees:

At least one foreign key is set
No more than one foreign key is set

If a row violates the rule, the insert or update fails immediately.

Why this is better than application-level checks

You could enforce this rule in your application layer, but that leaves room for:

Race conditions
Multiple services writing to the same database
Future code paths forgetting the rule

A CHECK constraint keeps the invariant inside the database, where it belongs.

Variations

If your requirement is “at most one” instead of “exactly one”, you can adjust the constraint:

CHECK (num_nonnulls(assoc_a_id, assoc_b_id, assoc_c_id) <= 1)

If you later add a new polymorphic target, you must update the constraint to include the new column.

When to use this pattern

This approach works well when:

You need strict relational integrity.
The set of polymorphic targets is finite and known.
You want predictable query performance without an additional type column.

If your targets are dynamic or numerous, a more classic polymorphic design (e.g. target_type + target_id) may be more flexible, though it trades off referential integrity.

Conclusion

num_nonnulls is a small but powerful feature in PostgreSQL. It allows you to enforce a subtle but important invariant with a single CHECK constraint, keeping your polymorphic associations consistent and safe at the database level.

It’s one of those features that feels obvious once you know it exists.

#pattern #database #postgresql #sql

🔗 Pausing traffic and retrying in Caddy

2026-03-27T14:00:00Z

A pattern I really like for zero-downtime deploys is the ability to "pause" HTTP traffic at the load balancer, such that incoming requests from browsers appear to take a few extra seconds to return, but under the hood they've actually been held in a queue while a backend server is swapped out or upgraded in some way.

Continue reading on github.com

#reading-list #pattern #http

🐥 YellowDuck.be

🔗 Designing AI features that actually help users

🔗 Using ClickHouse as a webhook endpoint with HMAC verification

🔗 Re-Implementing the Google Reader API in 2025

🔗 Thinking Elixir Podcast 297: JavaScript Joins the BEAM?

🔗 AI should help us produce better code

🐥 Installing Claude Code on macOS with Homebrew (and getting the latest version)

Install the latest version

Fix an existing installation

Why this matters

More context

Takeaway

🔗 Why use static closures?

🔗 Type systems are leaky abstractions: the case of Map.take!/2

🔗 How do you know if you’re a good leader?

🔗 Good software knows when to stop

🔗 Using systemd units for Laravel cronjobs and background processes

🐥 Taming scrollbars in a Phoenix app

The problem

The solution

Why this feels better

Browser support

🔗 Weaving stories with cascading workflows

🔗 Things I miss about Spring Boot after switching to Go

🐥 A better way: Using mkcert for HTTPS in Phoenix on macOS

What makes mkcert different?

Step 1: Install mkcert and register the local CA

Step 2: Generate a certificate for localhost

Step 3: Configure Phoenix for HTTPS

What about the cert files in version control?

Upgrading from the old approach

🔗 A minimalist HTTP library for Go

🔗 Batch inserts in SQL for large data loads

🐥 Fixing a race condition in Oban job counting with telemetry

The Setup

The Bug

The Fix: Oban Telemetry

Why This Works

Takeaway

🔗 Why I stopped using AI code editors

🔗 Your agent framework is just a bad clone of Elixir: concurrency lessons from telecom to AI

🐥 TIL: filtering GitHub PRs that are ready for review and not yours

What this does

Bonus: explore more filters

🔗 Easily connecting to BEAM nodes in Kubernetes with kubectl-beam

🔗 Nobody gets promoted for simplicity

🐥 Enforcing polymorphic integrity in PostgreSQL with num_nonnulls

The num_nonnulls function

Why this is better than application-level checks

Variations

When to use this pattern

Conclusion

🔗 Pausing traffic and retrying in Caddy

The `num_nonnulls` function