🐥 YellowDuck.be

🔗 Rewriting Bun in Rust

2026-08-04T13:00:00Z

Bun's evolution from Zig to Rust was not just a coding challenge; it aimed to resolve fundamental stability issues. The article details the ambitious journey of rewriting Bun's large codebase to enhance memory safety and eliminate bugs inherent in manual memory management. Originally a port from Go to Zig, the developer recognized weaknesses in Zig's handling of garbage-collected and manually-managed memory. By leveraging a new model from Anthropic, the team performed an efficient mechanical port to Rust, thus enabling safer code practices through Rust's strong type system and automatic memory management. The result? A more robust Bun, aiming for long-term stability and performance enhancement without sacrificing its original feature set. It's a case study in planning, execution, and leveraging AI in software development for increased reliability.

Continue reading on bun.com

#reading-list #rust #development #ai

🔗 Ever run into a PostgreSQL query that you can figure out what it does??

2026-08-04T08:00:00Z

Ever encountered an indecipherable PostgreSQL query that you still need to support? This article outlines how DBeaver's AI Assistant can demystify complex queries for users. With DBeaver 26.1.2, the AI Assistant analyzes queries and provides understandable explanations. The author illustrates this tool's efficacy using a sample query that identifies the top 10 most popular films by rental count and total revenue. From common table expressions (CTEs) to subqueries, the breakdown makes clear how the query's elements interact to produce results, highlighting the AI's utility when faced with obfuscated SQL. This guide empowers developers and database administrators to tackle intimidating SQL queries with confidence, showcasing an essential feature for anyone working with PostgreSQL.

Continue reading on stokerpostgresql.blogspot.com

#reading-list #database #ai #postgresql #sql

🐥 Adding 2FA to Phoenix LiveView with phx.gen.auth

2026-08-03T17:00:00Z

Two-factor authentication (2FA) is a great way to improve account security. This post walks through how to add TOTP-based 2FA to a Phoenix LiveView app using the built-in phx.gen.auth authentication system.

We’ll cover:

Adding required fields and dependencies
2FA setup flow using LiveView
TOTP challenge during login
LiveView-specific login handling

Add dependencies

Add the following libraries to mix.exs:

defp deps do
  [
    {:nimble_totp, "~> 1.0"},
    {:qr_code, "~> 2.2"}
  ]
end

Then run:

mix deps.get

Extend the user schema

Add two fields to your users table:

# priv/repo/migrations/*_add_totp_to_users.exs
alter table(:users) do
  add :totp_secret, :string
  add :totp_confirmed_at, :utc_datetime
end

Migrate:

mix ecto.migrate

In your user schema:

schema "users" do
  field :totp_secret, :string
  field :totp_confirmed_at, :utc_datetime
  # ...
end

Ensure your changeset/2 casts these fields:

def changeset(user, attrs) do
  user
  |> cast(attrs, [:email, :totp_secret, :totp_confirmed_at])
  |> validate_required([:email])
end

Add 2FA setup LiveView

Create a new LiveView at /settings/two_factor that generates a secret, renders a QR code, and lets the user enter their TOTP code.

defmodule MyAppWeb.TwoFactorSetupLive do
  use MyAppWeb, :live_view
  alias NimbleTOTP
  alias QRCode
  alias MyApp.Accounts

  def mount(_params, _session, socket) do
    user = socket.assigns.current_user

    if user.totp_secret do
      {:ok, assign(socket, setup?: false)}
    else
      secret = Base.encode32(NimbleTOTP.secret())
      uri = NimbleTOTP.otpauth_uri("MyApp:#{user.email}", Base.decode32!(secret), issuer: "MyApp")
      {:ok, png} = QRCode.create(uri, :png)
      b64 = Base.encode64(png)

      {:ok,
       assign(socket,
         setup?: true,
         secret: secret,
         qr_code: "data:image/png;base64,#{b64}",
         code: "",
         error: nil
       )}
    end
  end

  def handle_event("verify", %{"code" => code}, socket) do
    secret = Base.decode32!(socket.assigns.secret)

    if NimbleTOTP.valid?(secret, code) do
      {:ok, _} =
        Accounts.update_user(socket.assigns.current_user, %{
          totp_secret: socket.assigns.secret,
          totp_confirmed_at: DateTime.utc_now()
        })

      {:noreply,
       socket
       |> put_flash(:info, "2FA enabled.")
       |> push_redirect(to: "/settings")}
    else
      {:noreply, assign(socket, error: "Invalid code")}
    end
  end
end


<h1>Two-Factor Authenticationh1>

<%= if @setup? do %>
  <p>Scan this QR code in your authenticator app:p>
  <img src={@qr_code} />

  <form phx-submit="verify">
    <label>Code:label>
    <input type="text" name="code" />
    <button>Verifybutton>
  form>

  <%= if @error, do: content_tag(:p, @error, class: "text-red-500") %>
<% else %>
  <p>2FA is already enabled.p>
<% end %>

Add a TOTP challenge LiveView

When a user logs in with 2FA enabled, redirect them to a LiveView at /two_factor to enter their code.

defmodule MyAppWeb.TwoFactorChallengeLive do
  use MyAppWeb, :live_view
  alias MyApp.Accounts
  alias NimbleTOTP
  alias MyAppWeb.UserAuth

  def mount(_params, %{"pending_user_id" => id}, socket) do
    {:ok, assign(socket, user: Accounts.get_user!(id), code: "", error: nil)}
  end

  def handle_event("verify", %{"code" => code}, socket) do
    user = socket.assigns.user

    if NimbleTOTP.valid?(Base.decode32!(user.totp_secret), code) do
      {:noreply,
       socket
       |> put_flash(:info, "Logged in with 2FA.")
       |> UserAuth.log_in_user(user, %{})}
    else
      {:noreply, assign(socket, error: "Invalid code")}
    end
  end
end


<h1>Enter your 2FA codeh1>

<form phx-submit="verify">
  <input type="text" name="code" />
  <button>Verifybutton>
form>

<%= if @error, do: content_tag(:p, @error, class: "text-red-500") %>

Update login logic

After validating the user’s password (in your LiveView or controller), check if TOTP is enabled:

if user.totp_confirmed_at do
  socket
  |> Phoenix.LiveView.put_session(:pending_user_id, user.id)
  |> Phoenix.LiveView.redirect(to: "/two_factor")
else
  UserAuth.log_in_user(socket, user, %{})
end

In controllers, you’d use put_session(conn, ...) and redirect(conn, ...) instead.

Update `UserAuth` helper

Make sure your UserAuth module has a LiveView-compatible log_in_user/3:

def log_in_user(socket, user, _params \\ %{}) do
  token = MyApp.Accounts.generate_user_session_token(user)

  socket
  |> Phoenix.LiveView.put_session(:user_token, token)
  |> Phoenix.LiveView.redirect(to: "/")
end

Done

You now have a working TOTP 2FA flow in Phoenix LiveView:

Users opt in to 2FA in their settings
A QR code is shown and confirmed
2FA is required on next login
All handled with clean LiveView flows

From here, you can extend the system with:

Disabling 2FA
Backup codes
Remembering trusted devices

Let me know if you'd like a follow-up on any of those features.

#elixir #phoenix #auth

🔗 More shell patterns I use weekly

2026-08-03T13:00:00Z

This article shares useful Bash patterns and techniques that boost productivity for everyday tasks. The author highlights various methods like using sed and xargs for find-and-replace operations, employing while loops until success, and parallelizing commands with wait. The discussion emphasizes the importance of clean output and error handling, using temporary directories for logs with mktemp, and enhancing user legibility with color-coded output. The author also advocates for efficient file manipulation using shell constructs, recommending awk for filtering data instead of grep. These patterns, though simple, can significantly streamline workflows, especially for those working with commands regularly.

Continue reading on will-keleher.com

#reading-list #best-practice #terminal #linux

🔗 Why backlogs are harmful, why they never shrink, and what to do instead

2026-08-03T08:00:00Z

Backlogs never shrink, and their existence often leads to unproductive practices. When teams rely on them, they merely accumulate tasks that distract from prioritizing what truly matters. The article points out that important tasks rarely enter the backlog as teams instinctively know what needs immediate attention. This misalignment causes waste and elongates cycle times, as tasks languish unattended. A well-managed product team can avoid the pitfalls of backlogs by employing a high-level roadmap and maintaining close communication with engineers. In practice, this means regularly revisiting goals, effectively filtering bugs, and keeping the focus on immediate tasks. The author argues that instead of allowing unnecessary tasks to clutter workflows, it’s essential to be ruthless in prioritization and decision-making to enhance productivity and strategic alignment.

Continue reading on www.lucasfcosta.com

#reading-list #development #best-practice

🔗 The Laravel Scheduler Under the Hood

2026-08-02T17:00:00Z

Laravel's Scheduler features an API that simplifies task scheduling, but its underlying mechanics are crucial to understand. When cron triggers php artisan schedule:run, Laravel takes over to determine which events are due. This article dives deep into the Laravel Scheduler, explaining how it processes scheduled tasks, from command definitions to execution. It clarifies concepts like onOneServer() and withoutOverlapping(), which are essential for managing concurrent tasks. Readers learn how Laravel creates event objects from command definitions and how frequency methods adjust cron expressions. The article emphasizes the distinctions between the Scheduler and the Queue system, underpinning the operational design decisions that make task scheduling effective in production environments. Armed with this insight, Laravel developers can better leverage the Scheduler for reliable task execution.

Continue reading on wendelladriel.com

#reading-list #development #laravel #best-practice

🔗 Waze now supports electric vehicles in Belgium

2026-08-02T13:00:00Z

Finding a charging station for your electric vehicle won't be difficult anymore. Waze has added full support for electric charging points on its map in Belgium, enabling users to enter their car and plug type. This upgrade allows Waze to pinpoint all available charging points in your vicinity or along your route.

Thanks to the dedicated volunteer map editors, reliable information on charging points is now accessible. The community has worked tirelessly to update the Waze map with this critical data, ensuring it remains current. To configure electric vehicle support, users can navigate to Settings -> Vehicle Details -> Electric vehicles and toggle the EV features on, allowing them to easily find the nearest charging station. Users can also report outdated charging points for the community editors to review and update accordingly.

Continue reading on www.wazebelgium.be

#reading-list #announcement

🔗 Claude Code sends 4.7x more tokens than OpenCode before reading your prompt

2026-08-02T08:00:00Z

Claude Code's appetite for tokens far exceeds that of OpenCode, as the article reveals startling figures from direct comparisons. In experiments run under identical conditions, Claude Code averaged around 33,000 tokens for a one-line reply, while OpenCode only consumed about 7,000. The data reported showcases how Claude Code’s approach introduces significant cache inefficiencies, requiring 54 times more tokens for some tasks. A primary concern raised is the impact on production environments, particularly when operating under regulations like the EU AI Act. The emphasis is on understanding the tokens spent is crucial for optimizing agentic AI systems, where every token represents context that can't be utilized for task completion. Additionally, analyzing not just input but also cache writes reveals the complexity and potential costs associated with these AI harnesses.

Continue reading on systima.ai

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

🔗 Software has changed

2026-08-01T17:00:00Z

A surprising truth reveals how quickly the software landscape has transformed. In a recent tweet, Jamon Holmgren notes that many experienced engineers feel shell-shocked by these rapid changes. Development cycles are faster, yet there's a concern about not building the right things. The industry has shifted from deep focus to a management of constant new experiments, allowing for greater code review and refinement.

Building faster doesn’t mean building better, but it does free up developers to tackle technical debt proactively. Holmgren reflects on this evolution, pondering the implications of how code is created versus its final quality. With the ability to learn and adapt, many are navigating this new landscape while aiming to produce trusted, quality code.

Continue reading on www.abeautifulsite.net

#reading-list #development #best-practice

🔗 Zig creator calls spade a spade, Anthropic blows smoke

2026-08-01T13:00:00Z

Anthropic's ambitious narrative suggests software engineering will vanish, backed by a staggering $132 billion investment and a looming IPO. However, skepticism is essential; with no profitability in sight, decisions based on such hype could lead to misguided architecture and staffing choices driven by fear. Andrew Kelley, the creator of Zig, openly criticized the migration of the Bun project from Zig to Rust, framing it as a marketing ploy rather than a technical necessity. This situation raises questions not only about the software's future but also about the reliability of narratives shaped by significant financial backing. With Bun’s heavy reliance on AI and the subsequent shift, the community now grapples with the implications of these choices in a world where every programming language is scrutinized against performance and credibility measures. The drama unfolds not just in technical decisions, but in the larger discourse around automation and responsibility in software development.

Continue reading on raymyers.org

#reading-list #rust #development #ai

🔗 De Morgan’s Law

2026-08-01T08:00:00Z

Logical expressions can turn complex quickly, but understanding De Morgan’s Law can simplify them effectively. This principle, attributed to Augustus de Morgan in the 19th century, states that certain expressions using NOT, AND, and OR operations can be rewritten without changing their results. For instance, NOT(A) AND NOT(B) is equivalent to NOT(A OR B). Tracy Gilmore illustrates this concept with practical examples, including a detailed breakdown of truth tables and expressions. The article provides a clear guide on how to apply De Morgan’s Law to make code more readable and efficient. It's a valuable resource for programmers looking to improve their logical condition handling and streamline their code without the harsh symbols of Boolean algebra. Gilmore’s straightforward explanations make the law accessible for both seasoned developers and those newer to coding.

Continue reading on dev.to

#reading-list #development #best-practice

🔗 The Order of Data: defaults, performance, determinism & paging

2026-07-31T17:00:00Z

What happens when an SQL query doesn't specify the ORDER BY clause? This article breaks down the consequences of relying on the default sorting behavior across different databases such as Postgres, MySQL, and MongoDB. It illustrates with detailed SQL operations how Postgres defaults to insertion order, while MySQL may sort rows by primary key. It also points out the risks of assuming that the default order will remain consistent after updates or deletions. The author emphasizes that each database's handling of data ordering can affect performance and predictability, making it crucial for developers to be explicit in their ordering strategy.

Continue reading on binaryigor.com

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

🔗 Small programming tricks

2026-07-31T13:00:00Z

Small nuggets of knowledge can significantly enhance engineering productivity. This article reveals useful programming tricks that don't require extensive prior knowledge. For instance, using python3 -m http.server for quickly starting a simple server is highlighted. The author also suggests tools like fzf for fuzzy searching terminal history, atuin for a searchable SQLite database of shell history, and practical database commands such as SELECT without a FROM. Techniques in regular expressions, modern JavaScript capabilities, and efficient git commands are discussed as well. These tricks emphasize that even minor insights can lead to substantial efficiency gains in programming tasks. Sharing these nuggets within teams can foster a culture of learning and continuous improvement. Inspired by Julia Evan's approach, the article emphasizes that small bits of knowledge are both powerful and enjoyable to learn.

Continue reading on will-keleher.com

#reading-list #development #python #tools #terminal #git

🔗 Lucas' Laws of Project Management

2026-07-31T08:00:00Z

A project’s success hinges on solving the actual problem, rather than solely adhering to a specification. Surprisingly, compliance with the initial scope is often misguided because the primary focus should be on user needs. As a project unfolds, the understanding of the problem evolves, necessitating adaptations in the solution. Prioritizing problem comprehension over rigid scope planning is key. As the article outlines, assumptions must be tested not for their ease but based on their potential cost if proven wrong. It emphasizes the importance of clear communication and shared understanding within the team, advocating for a streamlined backlog and adaptable plans. This method ensures that projects remain viable, meet deadlines, and continuously provide value throughout their lifecycle.

Continue reading on lucasfcosta.com

#reading-list #development #best-practice

🔗 Go-flavored concurrency in C

2026-07-30T17:00:00Z

Go's concurrency model is attractive, but can it be mimicked in C using POSIX threads? This article delves into that question, exploring how to forge Go-like concurrency in C without runtime support and garbage collection. The writer introduces Solod, a strict Go subset that compiles to C, utilizing POSIX thread constructs such as mutexes and condition variables as its foundation.

The piece details various concurrency mechanisms like atomics, the worker pool, and task scheduling. Specific code snippets illustrate the direct translations from So to C, shedding light on performance trade-offs inherent to using OS threads versus lightweight goroutines. The core takeaway is clear: while achieving Go-like concurrency in C is challenging due to the shortcomings of POSIX threads, significant capabilities remain realizable by leveraging the right primitives and accepting the associated trade-offs.

Continue reading on antonz.org

#reading-list #golang #development #pattern

🔗 My AI learning journey

2026-07-30T13:00:00Z

Metrics have always been the so-called magic beans for improving quality in testing and quality engineering. In her article, Lisa Crispin emphasizes the importance of measuring AI success and quality improvement. She shares her decades of experience in the field and highlights how continuous quality improvement is crucial for modern software teams. The discussion revolves around effective metrics that can drive quality initiatives, making the case for an analytical approach to testing. Crispin brings a fresh perspective on harnessing metrics to elevate both AI performance and overall product quality.

Continue reading on lisacrispin.com

#reading-list #best-practice #ai #testing

🔗 Good tools are delightful

2026-07-30T08:00:00Z

Good tools are designed with the user's needs in mind, leading to unexpected delight and increased productivity. Zach Daniel emphasizes how tools like Neovim create opportunities for learning and improvement, rather than simply fading into the background. He reflects on his own experience with plugins such as Neogit, which enhanced his understanding and efficiency in managing code. Daniel critiques the idea that effective tools should be invisible, arguing instead for tools that challenge users to grow. He also touches on the evolving landscape of tools with the rise of LLMs, noting their potential to streamline workflows without sacrificing depth. Ultimately, he champions the view that while good tools may disappear, the best ones empower and delight users.

Continue reading on www.zachdaniel.dev

#reading-list #development #tools #ai

🔗 Two database migrations and a divorce

2026-07-29T17:00:00Z

Jack Ellis narrates the journey of migrating Fathom Analytics to a new database structure while eliminating significant technical debt. This complex project, which involved moving over 65 billion rows, was accomplished by a single engineer. Ellis discusses the challenges faced, particularly concerning cookie laws, user privacy, and the evolution of their data ingestion model. A pivotal moment arose when they concluded that traditional methods of tracking unique visitors could not align with emerging privacy standards. The team innovated with daily salts and hashing, paving the way for a privacy-first approach in analytics. However, years of technical debt complicated their architecture, leading to issues like broken queries and inability to scale. The article provides detailed insights into the considerations and decisions that shaped this significant migration, reflecting on lessons learned and how they evolved their analytics solutions for better performance and privacy.

Continue reading on usefathom.com

#reading-list #database #best-practice #devops

🔗 Claude.md is RAM, not disk

2026-07-29T13:00:00Z

Claude.md serves as working memory that needs to stay concise to remain effective. Alberto Arena highlights the pitfalls of allowing it to grow unwieldy, leading to reduced performance. Instead of cramming all information into this singular file, he advocates using it for essential, frequently required commands and pointers, while storing less frequently accessed information in separate documents. This distinction helps Claude manage context more efficiently and reduces unnecessary cognitive load. Applying this strategy means better interaction with the AI, as it has immediate access to crucial data while longer-term documentation resides in designated locations, unfettered by the immediate operational needs. Simplifying the architecture around how data is organized can significantly enhance coding workflows, especially in significant frameworks like Laravel.

Continue reading on albertoarena.it

#reading-list #laravel #best-practice #ai

🔗 I think I have LLM burnout

2026-07-29T08:00:00Z

Is burnout from large language models (LLMs) a real issue? The article reflects on the author's heavy usage of LLMs like Claude Code and Codex for daily tasks, expressing both productivity gains and mounting frustrations. After a year of constant interaction with AI-generated content, the author finds themselves increasingly annoyed by repetitive patterns, inaccuracies, and the overall style of LLM output—leading to feelings of fatigue towards these tools. Despite the productivity benefits, they acknowledge a shift in their disposition, grappling with the challenge of managing expectations and the limitations of LLMs. While the fascination remains, the growing irritation complicates their experience and relationship with AI.

Continue reading on www.alecscollon.com

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

🐥 Finding unexpected HTTP responses in JSON logs with jq

2026-07-28T17:00:00Z

When debugging an application in production, I often want a quick overview of requests that didn't result in a "normal" HTTP response. If your web server writes JSON logs, jq makes this incredibly easy.

Here's a command I regularly use:

cat access_*.log \
  | jq -r '
      select(
        .status != 200 and
        .status != 206 and
        .status != 302 and
        .status != 304 and
        .status != 308 and
        .status != 101
      )
      | [.status, .request.uri]
      | @csv
    ' \
  | uniq

The output looks something like this:

404,"/api/v1/users/..."
403,"/admin/..."
429,"/api/v1/search"
500,"/api/v1/orders/..."

What this does

The command performs three simple steps:

Reads all matching access log files.
Filters out the expected HTTP status codes (200, 206, 302, 304, 308, and 101).
Outputs the remaining status code together with the requested URI as CSV.

Finally, uniq removes duplicate entries so you get a concise overview instead of thousands of repeated requests.

Why this is useful

This is an easy way to spot things like:

Missing routes (404)
Authorization issues (401/403)
Rate limiting (429)
Unexpected server errors (500)
Any other response that deserves investigation

Instead of searching through millions of log lines, you immediately get a list of unique problem endpoints.

A small improvement

If your logs aren't already grouped, consider sorting before calling uniq:

cat access_*.log \
  | jq -r '
      select(
        .status != 200 and
        .status != 206 and
        .status != 302 and
        .status != 304 and
        .status != 308 and
        .status != 101
      )
      | [.status, .request.uri]
      | @csv
    ' \
  | sort \
  | uniq

Or, even shorter:

...
| sort -u

It's a simple one-liner, but it's become one of my favourite ways to quickly identify unexpected responses in production logs.

#tools #logging #http

🔗 HTTP query method support in Laravel 13.19

2026-07-28T13:00:00Z

Laravel 13.19.0 introduces support for the HTTP QUERY method across its HTTP client and testing helpers. The new Http::query() method allows users to issue QUERY requests, sending parameters in the request body rather than the URL. This mirrors existing methods like post(), put(), and patch() and defaults to sending JSON data.

The article also covers new testing helpers: query() and queryJson(), which facilitate testing routes that respond to QUERY requests. Additionally, a new collection method, reduceInto(), is introduced for more effective accumulator handling. Other enhancements include the counted() string helper to streamline word pluralization, bulk SQS dispatch improvements, and numerous bug fixes and optimizations. This release reflects Laravel's commitment to evolving and refining its framework.

Continue reading on laravel-news.com

#reading-list #laravel #php #http #testing

🔗 Tower 17 for Mac (Beta) — smarter "fully merged" detection

2026-07-28T08:00:00Z

Tower 17 for Mac, now in Beta, introduces significantly smarter "Fully Merged" detection. This update allows Tower to match local branches against merged pull requests from hosting services like GitHub and GitLab. Previously, users faced uncertainty when deleting branches that were squash or rebase merged, leading to cluttered projects with irrelevant branches. With this release, Tower employs advanced checks, including Git's classic merge detection and merge commit analysis, to accurately identify if branches are fully merged.

The redesigned hint view enhances transparency, showing exactly which checks applied when determining if a branch can be safely deleted. Users can also quickly access merge commits or pull requests for verification. Additional improvements enhance the application’s performance, particularly in updating submodules. Tower's new features aim to streamline users' workflows and make branch management safer and more intuitive.

Continue reading on www.git-tower.com

#reading-list #tools #github #git #mac

🔗 Announcing TypeScript 7.0

2026-07-27T17:00:00Z

TypeScript 7 has arrived, boasting a native port that is reported to be 10 times faster than its predecessor. This major rewrite was done in Go, allowing it to leverage modern hardware effectively. Developers can expect significant speedups in various operations like find-all-references, auto-completions, and diagnostics, with build times seeing improvements between 8x and 12x on common open-source projects. Notably, TypeScript 7 is designed for seamless integration with popular editors such as VS Code and Visual Studio. Initial tests reveal the new version reduces memory usage while enhancing responsiveness. Major companies, including Google and Microsoft, have tested and adopted TypeScript 7, reporting drastically improved performance. As it currently stands, TypeScript 7 can run alongside version 6, ensuring a smooth transition for ongoing projects. Tight feedback loops and aggressive testing have also bolstered quality, making this release one of the most stable yet.

Continue reading on devblogs.microsoft.com

#reading-list #typescript #development #tools #announcement

🔗 The four horsemen behind thousands of Postgres outages

2026-07-27T13:00:00Z

Postgres outages often stem from preventable issues related to vacuum operations, connection limits, and query planning. Many startups face downtime due to insufficient handling of transaction ID wraparound and I/O competition caused by vacuum processes. The author highlights innovative solutions through pgrust, a reimplementation of Postgres, which aims to offer a modern architecture, including 64-bit transaction IDs and thread-based processing for better resource management. The article emphasizes the challenges posed by bad query plans and the need for improved JSON handling, acknowledging the frustrations caused by the existing limitations in Postgres. This proactive approach promises to address common pain points faced by users in real-world applications.

Continue reading on malisper.me

#reading-list #database #best-practice #postgresql #devops

🐥 YellowDuck.be

🔗 Rewriting Bun in Rust

🔗 Ever run into a PostgreSQL query that you can figure out what it does??

🐥 Adding 2FA to Phoenix LiveView with phx.gen.auth

Add dependencies

Extend the user schema

Add 2FA setup LiveView

Add a TOTP challenge LiveView

Update login logic

Update UserAuth helper

Done

🔗 More shell patterns I use weekly

🔗 Why backlogs are harmful, why they never shrink, and what to do instead

🔗 The Laravel Scheduler Under the Hood

🔗 Waze now supports electric vehicles in Belgium

🔗 Claude Code sends 4.7x more tokens than OpenCode before reading your prompt

🔗 Software has changed

🔗 Zig creator calls spade a spade, Anthropic blows smoke

🔗 De Morgan’s Law

🔗 The Order of Data: defaults, performance, determinism & paging

🔗 Small programming tricks

🔗 Lucas' Laws of Project Management

🔗 Go-flavored concurrency in C

🔗 My AI learning journey

🔗 Good tools are delightful

🔗 Two database migrations and a divorce

🔗 Claude.md is RAM, not disk

🔗 I think I have LLM burnout

🐥 Finding unexpected HTTP responses in JSON logs with jq

What this does

Why this is useful

A small improvement

🔗 HTTP query method support in Laravel 13.19

🔗 Tower 17 for Mac (Beta) — smarter "fully merged" detection

🔗 Announcing TypeScript 7.0

🔗 The four horsemen behind thousands of Postgres outages

Update `UserAuth` helper