🐥 YellowDuck.be

🐥 Calling a Rust crate from Elixir with Rustler (and getting it through CI)

2026-11-14T18:00:00Z

I wanted a proper "reader mode" for the articles I link to on this blog: fetch a page, strip the navigation, ads, and cookie banners, and keep only the article. In Rust, there's a crate for this called readex, which does exactly that and can even output Markdown.

My app is Elixir/Phoenix, so the obvious question was: how do I use a Rust crate from Elixir? The answer is Rustler, which lets you write NIFs (Native Implemented Functions) in Rust with safe, ergonomic bindings.

In this post, I'll walk through the whole process, from mix.exs to a green GitHub Actions pipeline, including the mistakes I made along the way.

Prerequisites: Rust and Rustler

Rustler compiles your Rust code as part of mix compile, so you need a Rust toolchain on every machine that builds the project. The easiest way is rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustc --version
cargo --version

Then add Rustler to your dependencies in mix.exs:

defp deps do
  [
    # ...
    {:rustler, "~> 0.38.0", runtime: false}
  ]
end

runtime: false is the right choice here: Rustler is only needed at compile time. The compiled library is loaded by your own module, not by the Rustler application.

mix deps.get

Scaffolding the NIF with `mix rustler.new`

Rustler ships with a generator that creates the Cargo project for you:

mix rustler.new

It asks for the name of the Elixir module that will host the NIF and the name of the crate. I used YellowduckBe.ArticleExtractor.Native and article_extractor.

This generates the following:

native/article_extractor/
├── Cargo.toml
├── README.md
└── src/
    └── lib.rs

The generated Cargo.toml is where we add the readex crate:

[package]
name = "article_extractor"
version = "0.1.0"
authors = []
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
rustler = "0.39.0"
readex = "0.19"

crate-type = ["cdylib"] makes Cargo produce a shared library that the BEAM can load.

You also don't want build artifacts in Git, so add this to .gitignore:

# Rust / Rustler
/target/
/native/**/target/
/priv/native/

priv/native/ is where Rustler copies the compiled library so that it ends up in your release.

Implementing `extract_article` in Rust

The first version of the NIF was a straightforward mapping of everything readex returns. Here's the core idea:

use readex::{extract_with, Options};
use rustler::NifStruct;

#[derive(NifStruct)]
#[module = "YellowduckBe.ArticleExtractor.Article"]
struct Article {
    title: Option<String>,
    text: String,
    html: Option<String>,
    word_count: usize,
    language: Option<String>,
    byline: Option<String>,
    excerpt: Option<String>,
    site_name: Option<String>,
    published_time: Option<String>,
}

#[rustler::nif(schedule = "DirtyCpu")]
fn extract_article(html: String, url: String) -> Result<Article, String> {
    let options = Options {
        include_html: true,
        ..Options::default()
    };

    let result = extract_with(&html, Some(&url), &options)
        .map_err(|error| format!("{error:?}"))?;

    Ok(Article {
        title: result.title,
        text: result.text,
        html: result.html,
        word_count: result.word_count,
        language: result.language,
        byline: result.byline,
        excerpt: result.excerpt,
        site_name: result.site_name,
        published_time: result.published_time,
    })
}

rustler::init!("Elixir.YellowduckBe.ArticleExtractor.Native");

A few details are worth noting:

#[derive(NifStruct)] with #[module = "..."] converts the Rust struct into an Elixir struct of that module. No manual encoding or decoding is needed.
Option<String> becomes either a string or nil on the Elixir side.
Result<Article, String> becomes {:ok, %Article{}} or {:error, "reason"}, so it works with with and case as you'd expect.
schedule = "DirtyCpu" is important. Parsing and scoring an HTML document can take a while. A normal NIF that runs for more than about a millisecond blocks a scheduler and hurts the whole VM's latency. Marking it as a dirty CPU NIF runs it on a separate scheduler pool.
rustler::init! registers the module the NIF is loaded into. The Elixir. prefix is how Elixir module names are represented in Erlang.

Exposing it to Elixir

On the Elixir side, you need three small pieces. First, the struct that NifStruct maps to:

defmodule YellowduckBe.ArticleExtractor.Article do
  defstruct [
    :title,
    :text,
    :html,
    :word_count,
    :language,
    :byline,
    :excerpt,
    :site_name,
    :published_time
  ]
end

Second, the module that loads the native library and declares the stubs:

defmodule YellowduckBe.ArticleExtractor.Native do
  use Rustler,
    otp_app: :yellowduck_be,
    crate: "article_extractor"

  # Replaced by the NIF once it's loaded.
  def extract_article(_html, _url),
    do: :erlang.nif_error(:nif_not_loaded)
end

The stub is overridden when the library loads. If you ever see :nif_not_loaded, the library didn't compile or load.

And third, a small public module, so the rest of the app doesn't need to know there's a NIF involved:

defmodule YellowduckBe.ArticleExtractor do
  alias YellowduckBe.ArticleExtractor.Native

  def extract(html, url) do
    Native.extract_article(html, url)
  end
end

If you want to swap out the implementation or mock it in tests, this is the seam to do it at.

Using it from Elixir

Using it from a LiveView is a matter of fetching the HTML with Req and passing it along:

defp load(url) do
  with {:ok, %{body: html}} <- Req.get(url),
       {:ok, article} <- ArticleExtractor.extract(html, url) do
    {:ok, %{page: article}}
  end
end

Or in an iex -S mix session:

iex> {:ok, %{body: html}} = Req.get("https://example.com/some-article")
iex> {:ok, article} = YellowduckBe.ArticleExtractor.extract(html, "https://example.com/some-article")
iex> article.title
"Some article"
iex> article.word_count
1234

Passing the URL is useful: readex uses it to resolve relative links and images.

Compiling it in CI/CD

Everything worked locally, so I pushed it, and the pipeline immediately failed. The GitHub runner didn't know it had to build Rust.

The fix is to install a Rust toolchain before the Elixir build. I use dtolnay/rust-toolchain:

- name: Install Rust
  uses: dtolnay/rust-toolchain@stable

My first attempt added this to the wrong job. My workflow has two jobs that compile the app (one to run the tests, one to build and deploy), and both need Rust. I added it to one, moved it to the other, and finally had to put it in both before the pipeline went green.

The lesson: every job that runs mix compile needs the Rust toolchain. Remember this when you add a job later.

Caching the Rust build

A cold build of a Rust crate with its dependencies takes minutes, far longer than the rest of my pipeline. Swatinem/rust-cache caches the Cargo registry and the target directory, keyed on your Cargo.lock:

- name: Install Rust
  uses: dtolnay/rust-toolchain@stable

- name: Setup Rust cache
  uses: Swatinem/rust-cache@v2
  with:
    workspaces: native/article_extractor

The workspaces option matters: by default, the action looks for Cargo.toml in the repository root. Since the crate lives in native/article_extractor, I have to tell it where to look.

While I was there, I also added restore-keys to the existing caches for _build and deps. Without them, a changed mix.lock means a full cache miss. With them, the most recent cache with the same prefix is restored, and only what changed gets rebuilt:

- name: Cache compiled build
  uses: actions/cache@v4
  with:
    path: _build
    key: ${{ runner.os }}-mix-build-${{ hashFiles('**/mix.lock') }}-${{ hashFiles('**/.tool-versions') }}
    restore-keys: |
      ${{ runner.os }}-mix-build-

I also replaced the UBUNTU_VERSION variable in the cache keys with runner.os, the built-in way to key a cache by platform.

The gotcha: force a recompile so the NIF is rebuilt

This one cost me the most time. The pipeline was green, the caches worked, and then the app crashed at runtime with :nif_not_loaded.

Here's what happens:

Rustler compiles the crate and copies the library into priv/native/.
priv/native/ is in .gitignore, so it isn't in the checkout.
_build is restored from cache, including the compiled .beam file for YellowduckBe.ArticleExtractor.Native.
Mix sees that nothing changed in the Elixir sources, concludes the app is up to date, and skips compiling it. The Rust compiler never runs, so priv/native/ stays empty.

The cache gave me stale Elixir bytecode without the native library it needs. The fix is to delete the compiled output of just my app (not the dependencies, which are the expensive part) before compiling:

- name: Force recompile of the app (rebuilds the Rust NIF into priv/native)
  run: rm -rf _build/${{ env.MIX_ENV }}/lib/yellowduck_be

Now Mix has to recompile the app, which invokes the Rustler compiler. The Rust build is already cached by rust-cache, and Rustler copies the library into priv/native/. You get the caching benefits and a correct build.

Adding Markdown support

Once everything was running, I considered what I actually wanted to display. Plain text loses all the structure, and raw HTML needs sanitising. readex has extract_to_markdown, which returns the clean article as Markdown, making it easy to render with an Elixir Markdown library.

I also simplified the struct: I dropped the fields I wasn't using (canonical_url, image, categories, tags), replaced the optional html with the original_html I was handed, and added markdown:

use readex::{extract_to_markdown, extract_with, Options};
use rustler::NifStruct;

#[derive(NifStruct)]
#[module = "YellowduckBe.ArticleExtractor.Article"]
struct Article {
    title: Option<String>,
    original_html: String,
    markdown: String,
    text: String,
    word_count: usize,
    language: Option<String>,
    byline: Option<String>,
    excerpt: Option<String>,
    site_name: Option<String>,
    published_time: Option<String>,
}

#[rustler::nif(schedule = "DirtyCpu")]
fn extract_article(html: String, url: String) -> Result<Article, String> {
    let options = Options::default();

    let extracted = extract_with(&html, Some(&url), &options)
        .map_err(|error| format!("{error:?}"))?;

    let markdown = extract_to_markdown(&html, Some(&url), &options)
        .map_err(|error| format!("{error:?}"))?;

    Ok(Article {
        title: extracted.title,
        original_html: html,
        markdown,
        text: extracted.text,
        word_count: extracted.word_count,
        language: extracted.language,
        byline: extracted.byline,
        excerpt: extracted.excerpt,
        site_name: extracted.site_name,
        published_time: extracted.published_time,
    })
}

rustler::init!("Elixir.YellowduckBe.ArticleExtractor.Native");

The Elixir struct must match, since NifStruct expects the fields to match:

defmodule YellowduckBe.ArticleExtractor.Article do
  defstruct [
    :title,
    :original_html,
    :markdown,
    :text,
    :word_count,
    :language,
    :byline,
    :excerpt,
    :site_name,
    :published_time
  ]
end

In the LiveView template, I can render it with MDEx:

<div id="readability-content" class="prose max-w-none dark:prose-invert">
  {safe_html(page.markdown |> MDEx.to_html!())}
</div>

Note that this extracts the article twice (once for the metadata, once for the Markdown). For my use case, the cost is negligible, and the code stays simple. If this ever shows up in a profile, it's the first thing I'd look at.

The Rust part was the easy bit. Rustler's derive macros make the boundary between Rust and Elixir nearly invisible, and dirty schedulers keep long-running work from hurting the VM.

The real work was in the pipeline:

Every job that compiles the app needs a Rust toolchain.
Use rust-cache with workspaces pointing at your crate.
Add restore-keys to your Mix caches so a small change doesn't trigger a full rebuild.
When you cache _build, force a recompile of your own app, or the NIF never gets built into priv/native.

And the result is a dependable article extractor in about 40 lines of Rust, running inside my Phoenix app with no extra services to run.

#rust #development #elixir #phoenix #github

🔗 Human PR review is next

2026-11-14T14:00:00Z

Writing code went first. Reviewing it looks like it's going the same way. William Martin articulates the evolving landscape of code review, drawing parallels with the shift from manual coding to AI-assisted writing. He suggests that the future of review may lie in utilizing AI tools to automate the process, drastically reducing the need for line-by-line scrutiny. Current practices, traditionally grounded in human oversight, are being challenged as developers adapt to more advanced models. Martin counters common objections about AI-generated code, emphasizing that iterative improvements and automated checks can lead to better outcomes than solely relying on human reviewers. The article concludes by urging engineers to rethink review methodologies, highlighting the importance of rules and guardrails before the code, to maintain quality amidst increasing speed.

Continue reading on scienceisneato.substack.com

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

🔗 Portman: Your friendly port manager

2026-11-14T09:00:00Z

Portman gives macOS users a straightforward way to manage their local TCP ports. With a single command, portman <port>, it identifies which process is using a specific port, letting developers quickly resolve conflicts. This tool, built in Go, can be installed easily via Homebrew, and it works by utilizing lsof to retrieve process details. Whether working with Apple Silicon or Intel Macs, Portman is designed to streamline the troubleshooting of port issues in development environments. The initial release, v0.1.0, already sets the groundwork, with future updates planned for more capabilities, including JSON output and Linux support. This project not only demonstrates practical development but also enhances CLI design knowledge for the creator.

Continue reading on arps18.github.io

#reading-list #golang #development #tools #terminal #mac

🔗 Why I think we should write our own PR descriptions

2026-11-13T18:00:00Z

Writing pull request descriptions should be a responsibility of developers, even when agents handle most of the implementation. It encourages understanding of the changes being reviewed and provides necessary context for human reviewers. The article argues that while tools like Claude and Codex can generate comprehensive descriptions, they can lack the personal touch and insights that come from the developer directly involved with the code.

The author emphasizes that a PR description should clarify why a change exists and how it fits into the broader project, rather than just detailing what was changed. By taking ownership of the PR description, developers not only ensure clarity for reviewers but also maintain a connection to the code being produced. This approach fosters a better understanding of the work being done and reinforces individual accountability in the development process.

Continue reading on laravel.com

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

🔗 Git mastery: Intermediate and professional workflows

2026-11-13T14:00:00Z

You push a feature branch on Friday, and by Monday, the history looks like a shuffled deck of cards. Git transitions from simply being a tool for git commit and git push to something that requires real understanding. This article by Arpan Patel delves into advanced Git concepts crucial for maintaining a clean workflow. It covers key techniques like interactive rebase for cleaning up history, the importance of reflog for recovery, effective branching strategies, and how to utilize git bisect for regression debugging. By mastering these workflows, developers can regain control over their commits and work seamlessly in collaborative environments. This guide encapsulates the essentials for elevating one's Git skills from basic to expert.

Continue reading on arps18.github.io

#reading-list #development #best-practice #git

🔗 Misconceptions about RSS

2026-11-13T09:00:00Z

Are misconceptions about RSS causing it to be underestimated in today’s digital landscape? Robert Alexander attempts to clarify common misconceptions regarding RSS, highlighting its significant presence across platforms like YouTube, Reddit, and podcasting. He addresses myths such as RSS being niche or dying, as well as the false belief in its poor discoverability. The article argues that RSS remains powerful, proving essential for timely updates across various content types, from job listings to weather reports. Alexander points out the ongoing evolution and innovation within the RSS ecosystem, challenging the notion that RSS has stagnated. The piece invites readers to recognize the value of RSS as a tool that empowers users in a media landscape often dominated by companies prioritizing advertisements over genuine content.

Continue reading on alexsci.com

#reading-list #tools

🐥 Passing Maps and Enums with Rust NIFs in Elixir

2026-11-12T18:00:00Z

In addition to structs, you can pass maps and enums between Elixir and Rust when writing Native Implemented Functions (NIFs) with Rustler. This gives you flexibility when working with more dynamic or variant data.

Passing maps from Elixir to Rust

Elixir maps can be received in Rust as MapIterators or HashMaps, or decoded into Rust structs.

Example: reading keys from a map

use rustler::{MapIterator, NifResult, Term};

#[rustler::nif]
fn keys(map: Term) -> NifResult<Vec<String>> {
    MapIterator::new(map)
        .ok_or(rustler::Error::BadArg)?
        .map(|(k, _)| k.decode::<String>())
        .collect()
}

iex> MyNif.keys(%{"a" => 1, "b" => 2})
["a", "b"]

Example: decoding into a Rust struct

use rustler::{NifMap, NifResult, Term};

#[derive(NifMap)]
struct GreetUser {
    name: String,
    age: u32,
}

#[rustler::nif]
fn greet(user_term: Term) -> NifResult<String> {
    let user: GreetUser = user_term.decode()?;
    Ok(format!("Hello, {} (age {})", user.name, user.age))
}

iex> MyNif.greet(%{name: "Alice", age: 30})
"Hello, Alice (age 30)"

Passing enums from Elixir to Rust

Enums can be passed using tagged maps or atoms.

Rust enum:

#[derive(NifMap)]
struct Circle {
    radius: f64,
}

#[derive(NifMap)]
struct Rectangle {
    width: f64,
    height: f64,
}

enum Shape {
    Circle(Circle),
    Rectangle(Rectangle),
}

impl<'a> Decoder<'a> for Shape {
    fn decode(term: Term<'a>) -> NifResult<Self> {
        let key = Atom::from_str(term.get_env(), "type")?;
        let ty: String = term.map_get(key)?.decode()?;
        match ty.as_str() {
            "Circle" => Ok(Shape::Circle(term.decode()?)),
            "Rectangle" => Ok(Shape::Rectangle(term.decode()?)),
            _ => Err(Error::BadArg),
        }
    }
}

Function using the enum:

#[rustler::nif]
fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(Circle { radius }) => std::f64::consts::PI * radius * radius,
        Shape::Rectangle(Rectangle { width, height }) => width * height,
    }
}

Elixir usage:

iex> MyNif.area(%{type: "Circle", radius: 3.0})
28.274333882308138

iex> MyNif.area(%{type: "Rectangle", width: 4.0, height: 5.0})
20.0

Returning maps and enums from Rust to Elixir

To return dynamic structures like maps from Rust, construct them using Env and Rustler's term constructors.

Returning a map:

use rustler::{Env, Term, NifResult};

#[rustler::nif]
fn status_map<'a>(env: Env<'a>, code: u32) -> NifResult<Term<'a>> {
    let status = if code == 200 { "ok" } else { "error" };
    Term::map_new(env).map_put("status", status)
}

iex> MyNif.status_map(200)
%{"status" => "ok"}

Returning an enum as a tagged map

You can define a Rust enum and implement Encoder for it:

use rustler::{Encoder, Env, Term};

enum Response {
    Success { result: String },
    Error { reason: String },
}

// Elixir side:
//   %{"type" => "success", "result" => "done"}
//   %{"type" => "error", "reason" => "..."}
impl Encoder for Response {
    fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
        let pairs: Vec<(&str, &str)> = match self {
            Response::Success { result } => vec![("type", "success"), ("result", result)],
            Response::Error { reason } => vec![("type", "error"), ("reason", reason)],
        };

        let mut map = Term::map_new(env);
        for (k, v) in pairs {
            // String keys/values encode to Elixir binaries
            map = map.map_put(k, v).unwrap();
        }
        map
    }
}

#[rustler::nif]
fn status_map(code: u32) -> Response {
    if code == 200 {
        Response::Success { result: "done".to_string() }
    } else {
        Response::Error { reason: format!("unexpected code {}", code) }
    }
}

This allows you to return tagged maps like:

%{"type" => "success", "result" => "done"}

iex(1)> MyNif.status_map(200)
%{"result" => "done", "type" => "success"}
iex(2)> MyNif.status_map(500)
%{"reason" => "unexpected code 500", "type" => "error"}

Handling invalid input

Instead of calling .unwrap(), return a safe error from your NIF:

use rustler::{Atom, NifMap, Term};

rustler::atoms! {
    invalid_user_struct,
}

#[derive(NifMap)]
struct GreetUser {
    name: String,
}

#[rustler::nif]
fn safe_greet(user_term: Term) -> Result<String, Atom> {
    match user_term.decode::<GreetUser>() {
        Ok(u) => Ok(format!("Hello, {}", u.name)),
        Err(_) => Err(invalid_user_struct()),
    }
}

In Elixir:

iex> MyNif.safe_greet(%{name: "Bob"})
{:ok, "Hello, Bob"}

iex> MyNif.safe_greet(%{bad: "input"})
{:error, :invalid_user_struct}

#rust #elixir

🔗 The system around the code

2026-11-12T14:00:00Z

Many organizations experience an enthusiasm deflation when it comes to implementing the latest AI solutions. Zarar Siddiqi highlights that while dazzling demos captivate many, the harder truth involves the systems surrounding code rather than the code itself. Years of experience remind us that the path to deployment is often clouded by structural and organizational issues. A key example cited is an incident in which a developer's mistake was mischaracterized as an AI problem when in fact, the issue stemmed from poor engineering practices. This article emphasizes the importance of understanding these systems and structures to avoid repeating past mistakes. Siddiqi addresses how the transition to AI requires a focus on building robust systems that can manage increased complexity rather than merely implementing AI tools without consideration for their context and impact.

Continue reading on bitbytebit.substack.com

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

🔗 Stop resolving the same Git conflict twice

2026-11-12T09:00:00Z

A merge conflict is annoying once. Resolving the same one again on the next rebase feels like Git charging rent on a decision already made.

Git has a little-known feature for this: rerere, short for “reuse recorded resolution.” When enabled, it can remember how a conflict was resolved and reuse that fix when that conflict arises again. Simply turn it on by using git config --global rerere.enabled true. After resolving a conflict and committing it, rerere can automatically apply the previously recorded fix the next time the same conflict comes up, which is particularly useful when merging upstream changes frequently.

However, it’s crucial to inspect the result of any automatic resolution, as rerere only remembers the textual resolution, not the intent. If a remembered fix is inappropriate, you can use git rerere forget file_to_add.py to erase that resolution and resolve the conflict anew.

Continue reading on code.geohack.top

#reading-list #best-practice #git

🔗 MapSets: A set that's secretly a map

2026-11-11T18:00:00Z

What if a set could be more than just a collection of items? In the article, Bruce Tate sheds light on MapSet, revealing its hidden map structure and how it utilizes maps for efficient membership checks. He explains that MapSet allows for quick lookups like traditional maps, but provides set functionality where order doesn't matter and duplicates are ignored. Readers learn how to create sets, check for membership, and effectively manage expected behaviors when working with MapSet, all while emphasizing the importance of the underlying map data structure. By understanding these concepts, developers can choose better data structures for various scenarios, enhancing both performance and clarity in their Elixir applications.

Continue reading on grox.io

#reading-list #database #best-practice #elixir

🔗 A modern web app in C

2026-11-11T14:00:00Z

The decline of CGI in web development seemed set in stone in 2004, but in 2026 it's being reconsidered. Corey Prophitt highlights how he successfully built and launched a modern web application using C and CGI, showcasing a minimalistic stack including OpenBSD, SQLite, and essential libraries like libcurl and libsodium. This approach emphasizes the advantages of simplicity, low overhead, and fewer dependencies, making it possible to deliver a robust product without the complexities of modern frameworks. Prophitt argues that writing a CGI application today is feasible and effective, allowing developers to lean on their knowledge of HTTP without the burden of additional APIs. The article offers a glimpse into how leveraging timeless technologies can yield practical, less risky solutions in contemporary development.

Continue reading on prophitt.me

#reading-list #development #database #tools #http

🔗 My AI policy

2026-11-11T09:00:00Z

What happens when developers grapple with LLMs and community standards? This article tackles the challenges of expressing a personal stance on AI, balancing professional tools with ethical concerns. The author shares his journey and reflections on using LLMs to complement his work while confronting the larger issues of AI company practices. He questions the morality behind mass training on public content, highlighting the disconnect between content creators and the companies that profit from their work. As the web community faces increasing scrutiny over technology choices, he advocates for building a supportive environment instead of shaming others for their decisions. Whether discussing the ethics of AI or the pressures of public opinion, the piece provides a candid insight into the current landscape of development and AI integration.

Continue reading on remysharp.com

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

🐥 Passing Structs with a Rust NIF in Elixir

2026-11-10T18:00:00Z

When using Rust NIFs in Elixir via the Rustler crate, it's often useful to pass structured data, not just integers and strings. This post shows how to pass an Elixir struct to Rust, manipulate it, and return a new struct to Elixir.

Define a struct in Elixir

Start by creating a simple struct, such as User:

defmodule MyNif.User do
  defstruct [:name, :age]
end

Define the same struct in Rust

In your NIF crate (native/my_nif/src/lib.rs), define a matching Rust struct using Rustler's NifStruct derive macro:

use rustler::NifStruct;

#[derive(NifStruct)]
#[module = "MyNif.User"]
struct User {
    name: String,
    age: u32,
}

The #[module = "MyNif.User"] attribute tells Rustler how to map the Elixir struct to the Rust struct.

Write a NIF function that uses the struct

Here's a Rust NIF that increases a user's age:

#[rustler::nif]
fn birthday(user: User) -> User {
    User {
        age: user.age + 1,
        ..user
    }
}

rustler::init!("Elixir.MyNif");

Wire it up in Elixir

In your wrapper module:

defmodule MyNif do
  use Rustler, otp_app: :my_nif_app, crate: "my_nif"

  def birthday(_user), do: :erlang.nif_error(:nif_not_loaded)
end

Call it from IEx

$ iex -S mix
iex> user = %MyNif.User{name: "Alice", age: 29}
iex> MyNif.birthday(user)
%MyNif.User{name: "Alice", age: 30}

Notes

Fields must match exactly between Elixir and Rust.
Rustler will raise a badarg error if field names or types don't match.
NifStruct automatically handles encoding and decoding using serde.

#rust #elixir

🔗 I'm sorry, but you still have to think.

2026-11-10T14:00:00Z

DHH, the creator of Ruby on Rails, chose to rewrite Campfire Once from Ruby on Rails to Rust, relying on a developer to handle the Rust code due to his discomfort with it. This decision, along with rewrites in languages like Elixir and Go, offers insight into the challenges faced by those using AI agents for coding without understanding the code themselves. The results weren't promising; they highlighted the necessity of specificity in prompts, as many programming decisions come down to subjective choices. While Elixir's version stayed closer to the original Rails architecture, both rewrites exhibited significant trade-offs. Rust payments weak performance in certain aspects, including a low new post delivery rate under heavy load due to its limited broadcast channel capacity. The comparative analysis emphasizes that programming decisions are complex and a single metric doesn’t tell the whole story. Ultimately, it reinforces the importance of thoughtful coding practices and understanding the nuances of each programming language's features and limitations.

Continue reading on itsallaboutthebit.com

#reading-list #rust #development #ai

🔗 I've been the sole developer of a healthcare membership platform for 6+ years. Here's what it looks like.

2026-11-10T09:00:00Z

What does a healthcare membership platform look like after six years of sole development? Tim Kamanin shares insights from building a system that integrates member applications, payments, event management, and more using Django and Wagtail CMS. Initially created to address a pressing need, the platform has grown into a robust tool handling memberships, communications, and exams seamlessly. Key features include automatic status tracking, an internal email system, and independent management of events—allowing non-technical staff to efficiently handle operations. This article explains how Kamanin maintains a monolithic codebase with a simple frontend while staying attuned to every line of code and business rule. He highlights the advantages of being the sole developer: quick adaptations, clean code, and deep familiarity with the platform's architecture. A testament to streamlined software development in the healthcare sector, his experience illustrates the value of dedicated ownership in tech projects.

Continue reading on timonweb.com

#reading-list #development #database #best-practice #django #wagtail

🔗 Review fatigue is real. Here's what my team did about it

2026-11-09T18:00:00Z

Reviewing pull requests (PRs) can often take longer than writing the code itself. This phenomenon, highlighted by Ivan Pelivanovic, emphasizes that even as AI tools facilitate quicker coding, they don't necessarily streamline the review process. The increasing speed of code deployment can lead to an overwhelming volume of reviews, resulting in a state of review fatigue that teams struggle to manage. This article explores strategies some teams have implemented to tackle this issue, ensuring that code quality and thoroughness don't suffer in the rush to deliver results.

Continue reading on shiftmag.dev

#reading-list #development #best-practice #git

🔗 Why MCP was always a bad idea

2026-11-09T14:00:00Z

MCP was hailed as a necessary protocol when released by Anthropic in 2024, but the landscape has drastically changed. As LLMs became adept at executing code and autonomously calling APIs, MCP began to feel redundant. While it facilitated early integrations between AI models and external services, the evolution of these models means they can now interact directly with APIs without reliance on MCP, which often wraps existing services. The recent emergence of Cloudflare's Code Mode exemplifies how LLMs have outpaced the capabilities offered by MCP, composing scripts directly and omitting the need for intermediary servers. The article argues for a shift towards direct use of HTTP APIs and standard practices. Standardization could streamline interactions, making agents more efficient than ever before. Thus, embracing closure on MCP may very well be a strategic step forward in AI development.

Continue reading on maharship.com

#reading-list #http #ai

🔗 How I built Tjommi's backend

2026-11-09T09:00:00Z

Tjommi's backend integrates sophisticated data handling for tracking purchased products and claims. It processes varied formats like emails, PDFs, and screenshots into structured records. The article dives into the iterative development of this backend, documenting architectural choices and technological advancements spanning from 2019 to 2023. Key components include the use of receipt extraction, retailer integrations, and the introduction of AI for processing formats. The evolving modular architecture within a Laravel application ensures smooth functionality, while managing complexities tied to retailer behaviors. Overall, it highlights how continuous refinement and innovative technologies enhanced the claims process and improved customer experience.

Continue reading on helgesver.re

#reading-list #pdf #development #laravel #database #ai

🐥 Creating a Simple Elixir NIF Using Rust

2026-11-08T18:00:00Z

Elixir is great for many things, but sometimes you need raw speed or access to native libraries. That’s where Native Implemented Functions (NIFs) come in. This post walks through creating a simple Elixir NIF using Rust with the help of the rustler crate.

Set up your Elixir project

Start with a basic Elixir application:

mix new my_nif_app
cd my_nif_app

Add :rustler as a dependency in mix.exs:

defp deps do
  [
    {:rustler, "~> 0.38.0"}
  ]
end

Fetch the dependencies:

mix deps.get

Generate the Rust NIF scaffold

$ mix rustler.new
This is the name of the Elixir module the NIF module will be registered to.
Module name > MyNif
This is the name used for the generated Rust crate. The default is most likely fine.
Library name (mynif) > my_nif
Fetched latest rustler crate version: 0.39.0
* creating native/my_nif/README.md
* creating native/my_nif/Cargo.toml
* creating native/my_nif/src/lib.rs
* creating Cargo.toml
Updating .gitignore file

Ready to go! See native/my_nif/README.md for further instructions.

This command will:

Create a native/ directory
Scaffold a Rust crate
Link it into your Elixir project

Choose a crate name when prompted, such as my_nif.

Write a simple NIF in Rust

Open the generated native/my_nif/src/lib.rs file and replace its contents with:

#[rustler::nif]
fn add(a: i64, b: i64) -> i64 {
    a + b
}

rustler::init!("Elixir.MyNif");

This defines a basic add/2 function exposed to Elixir.

Define the Elixir wrapper

In lib/my_nif.ex, wire up the NIF:

defmodule MyNif do
  use Rustler, otp_app: :my_nif_app, crate: "my_nif"

  # Fallback when the NIF is not loaded
  def add(_a, _b), do: :erlang.nif_error(:nif_not_loaded)
end

Build and test

Compile the NIF:

mix compile

Then try it out in iex:

$ iex -S mix
iex> MyNif.add(2, 3)
5

You've created a simple Elixir NIF using Rust. This lets you use Rust's performance and ecosystem while retaining Elixir's productivity.

#rust #elixir

🔗 Why we started building on the Django 6.1 alpha

2026-11-08T14:00:00Z

Divio chose to adopt the Django 6.1 alpha long before its official release to actively contribute to its development. This decision was driven by their commitment to the Django community and the compelling new features Django 6.1 promised, such as database-level delete options and enhancements in the admin interface. By testing the pre-release daily, they not only utilized its advancements but also identified and reported several bugs, aiding the refinement of the framework. Their hands-on approach ensured they were at the forefront of developments and equipped them with insights into the new functionalities. As a result, Divio can now encourage others to explore Django 6.1, showcasing the readiness and potential of the framework for production use.

Continue reading on www.divio.com

#reading-list #database #django #testing

🔗 Shadcn datatable filtering

2026-11-08T09:00:00Z

A good datatable filter is essential for improving user experience by allowing for quick and easy access to specific data within large datasets. The Shadcn datatable filtering blocks combine search boxes, condition builders, and category filters to enhance the usability of data tables. These features allow users to narrow down their search through options like free-text search, stackable condition-based filters, and date range selectors, all while maintaining a seamless front-end experience using React and Tailwind CSS.

Additionally, the blocks work harmoniously with both Base UI and Radix UI, making integration straightforward. Users can employ the Shadcn Builder to effortlessly drag and drop these blocks into their projects, streamlining the layout process without the need for manual coding. The article thoroughly outlines the capabilities and use cases of these filtering blocks, which are a standout in the Shadcn studio library for efficient data handling.

Continue reading on shadcnstudio.com

#reading-list #javascript #frontend #css

🔗 django-absurd: ceci n'est pas un queue

2026-11-07T18:00:00Z

django-absurd integrates a Postgres-native workflow engine into Django, allowing developers to run background tasks and durable workflows seamlessly. It utilizes Django's existing database connection, minimizing overhead and setup complexity. To get started, developers must ensure compatibility with Python 3.12+, Django 6.0+, and use the psycopg driver. After adding django_absurd to the INSTALLED_APPS, the database schema is migrated, and tasks can be written using Django's @task decorator. The article outlines a straightforward task loop, from enqueuing to result retrieval, and highlights the use of workflow contexts for reliable task execution with checkpoints and retries. Key functionalities include tasks, workflows, cron jobs, worker management, and monitoring, making it a versatile solution for task management in Django applications.

Continue reading on lincolnloop.github.io

#reading-list #python #database #django

🔗 Django and deployments

2026-11-07T14:00:00Z

What if Django had a streamlined deploy command? This article contemplates the future of Django deployments, building on insights from Will Vincent's recent talks and suggestions from the community. The author, who is also the maintainer of django-prodserver, proposes conceptual stages for deployment, breaking them down into manageable commands. Key commands might include manage.py init_deploy_env and manage.py productionize. While there are myriad deployment strategies, the focus is on establishing a common API in Django that can aid in automating essential processes. By examining existing packages like django-production, the author suggests a pathway toward simplifying deployment in Django projects, inviting community feedback on the potential for such innovations.

Continue reading on softwarecrafts.co.uk

#reading-list #best-practice #django #devops

🔗 Django: Serve a security.txt file

2026-11-07T09:00:00Z

When a vulnerability is found on a site, security researchers often struggle to find a reliable way to report it. The solution? A security.txt file, standardized in April 2022, which lays out how to communicate security issues. This article provides a comprehensive guide on implementing a security.txt file in Django, serving it over HTTPS, and ensuring it remains current through unit tests and a custom system check. A thorough implementation is demonstrated, including the required content fields like Contact and Expires, as well as the code needed to serve the file and validate its integrity. Maintaining an updated security.txt file not only aids communication but is crucial for any web application’s security protocol. Adam Johnson expertly covers these aspects to ensure your site is prepared for researchers looking to communicate vulnerabilities effectively.

Continue reading on adamj.eu

#reading-list #best-practice #django #testing

🐥 Giving a Laravel Artisan Command an Alias

2026-11-06T18:00:00Z

Sooner or later, every codebase has a command whose name you can't remember. Say you have reports:generate-monthly. Half the team types reports:monthly from muscle memory and gets "Command not defined". You don't want to rename the command because runbooks, scripts, and Slack history all reference the old name. So you give it a second name.

The short version

Aliases are a Symfony Console feature, and Artisan is built on Symfony Console. Laravel supports them in three ways.

1. The `$aliases` property

class GenerateMonthlyReportCommand extends Command
{
    protected $signature = 'reports:generate-monthly {reportId}';

    protected $description = 'Generates the monthly report for the given id';

    protected $aliases = ['reports:monthly'];
}

Laravel's Command constructor reads this property and calls Symfony's setAliases() for you. This is the approach we use.

2. The `#[Aliases]` attribute

Laravel 13 also has class attributes for command metadata:

use Illuminate\Console\Attributes\Aliases;

#[Aliases(['reports:monthly'])]
class GenerateMonthlyReportCommand extends Command
{
    // ...
}

The #[Signature] attribute also accepts an aliases argument, so the signature and its aliases can sit together. Use whichever style your commands already use.

3. Overriding `configure()`

protected function configure(): void
{
    parent::configure();

    $this->setAliases(['reports:monthly']);
}

This works on any Laravel version because it uses plain Symfony. On recent versions, you rarely need it.

What you get

Both names run the same command with the same arguments and options:

php artisan reports:generate-monthly 123
php artisan reports:monthly 123

php artisan list shows the alias as its own entry and marks the canonical command with the alias in brackets, so people can see that the two names belong together:

reports:monthly            Generates the monthly report for the given id
reports:generate-monthly   [reports:monthly] Generates the monthly report for the given id

Gotchas

An alias is only a name. Don't put arguments or options in it. The signature ({reportId}) belongs to the command and is shared by every name. If you write 'reports:monthly {reportId}' as an alias, Symfony takes the whole string as the name, including the placeholder.
Aliases must be unique. Run php artisan list after adding one to check that it doesn't collide with another command.
Scheduling and queues. Schedule::command('reports:monthly'), $this->call(), and Artisan::call() all resolve aliases. Still, use the canonical name in code so a grep for the command finds every use.
Decide which name is canonical. The alias is a convenience. If you want people to move to the new name, make it the $signature name and keep the old one as the alias. That gives you a painless rename.
Test it. Run the command through its alias once in a test so a typo in the alias doesn't go unnoticed.

#laravel #php #tools

🐥 YellowDuck.be

🐥 Calling a Rust crate from Elixir with Rustler (and getting it through CI)

Prerequisites: Rust and Rustler

Scaffolding the NIF with mix rustler.new

Implementing extract_article in Rust

Exposing it to Elixir

Using it from Elixir

Compiling it in CI/CD

Caching the Rust build

The gotcha: force a recompile so the NIF is rebuilt

Adding Markdown support

🔗 Human PR review is next

🔗 Portman: Your friendly port manager

🔗 Why I think we should write our own PR descriptions

🔗 Git mastery: Intermediate and professional workflows

🔗 Misconceptions about RSS

🐥 Passing Maps and Enums with Rust NIFs in Elixir

Passing maps from Elixir to Rust

Example: reading keys from a map

Example: decoding into a Rust struct

Passing enums from Elixir to Rust

Rust enum:

Function using the enum:

Elixir usage:

Returning maps and enums from Rust to Elixir

Returning a map:

Returning an enum as a tagged map

Handling invalid input

🔗 The system around the code

🔗 Stop resolving the same Git conflict twice

🔗 MapSets: A set that's secretly a map

🔗 A modern web app in C

🔗 My AI policy

🐥 Passing Structs with a Rust NIF in Elixir

Define a struct in Elixir

Define the same struct in Rust

Write a NIF function that uses the struct

Wire it up in Elixir

Call it from IEx

Notes

🔗 I'm sorry, but you still have to think.

🔗 I've been the sole developer of a healthcare membership platform for 6+ years. Here's what it looks like.

🔗 Review fatigue is real. Here's what my team did about it

🔗 Why MCP was always a bad idea

🔗 How I built Tjommi's backend

🐥 Creating a Simple Elixir NIF Using Rust

Set up your Elixir project

Generate the Rust NIF scaffold

Write a simple NIF in Rust

Define the Elixir wrapper

Build and test

🔗 Why we started building on the Django 6.1 alpha

🔗 Shadcn datatable filtering

🔗 django-absurd: ceci n'est pas un queue

🔗 Django and deployments

🔗 Django: Serve a security.txt file

🐥 Giving a Laravel Artisan Command an Alias

The short version

1. The $aliases property

2. The #[Aliases] attribute

3. Overriding configure()

What you get

Gotchas

Scaffolding the NIF with `mix rustler.new`

Implementing `extract_article` in Rust

1. The `$aliases` property

2. The `#[Aliases]` attribute

3. Overriding `configure()`