🐥 YellowDuck.be

🔗 Why Pogačar rides on a car tire brand

2026-08-07T08:00:00Z

Why are pro cyclists like Tadej Pogačar riding on tires made by car manufacturers? Jan Heine reveals the surprising truth behind tire sponsorship in the Tour de France. While companies like Continental dominate road racing sponsorships, it's primarily car tires being promoted, not bike tires. With costs running into millions, small brands struggle to compete despite offering quality products. Heine highlights that while small makers find success in gravel races, the high stakes of pro cycling often favor larger brands willing to invest heavily. The article provides an insightful look into the financial strategies behind sponsorships in elite road racing, illustrating how marketing priorities can overshadow the sport's rich cycling heritage.

Continue reading on www.renehersecycles.com

#reading-list #sports

🔗 Your Dropbox is now a skill server

2026-08-06T17:00:00Z

sx 2.0, a new app for Mac, Windows, and Linux, addresses the challenge of sharing AI skills among non-technical teams. By using a shared folder in Dropbox or similar services, teams can easily publish and synchronize their skills without needing git or terminal access. The app translates skills into various AI client formats seamlessly, allowing for effortless integration.

Moreover, the release includes a pluggable extension system that enables teams to customize their workflows without bloating the core product. With built-in tools to monitor skill usage and ensure content quality, sx 2.0 targets marketing, legal, and sales teams who can now leverage AI without technical barriers through a simple, user-friendly interface. The emphasis on distribution aims to democratize access to AI knowledge across organizations.

Continue reading on sleuth-io.github.io

#reading-list #tools #ai #announcement

🔗 Kubernetes Dashboard to Headlamp: A Step-by-Step Guide

2026-08-06T13:00:00Z

Kubernetes Dashboard and Headlamp serve different roles in a cluster. Headlamp connects via kubeconfig, allowing for desktop or in-cluster usage, while the Kubernetes Dashboard is strictly in-cluster. This article breaks down the processes for migrating from Dashboard to Headlamp. It highlights key differences in user experience, installation methods, and permissions management. A pre-migration checklist ensures a smooth transition, emphasizing the importance of understanding RBAC rules. By suggesting rollout plans, it gives teams structure in their migration approach. Ultimately, Headlamp simplifies managing multiple clusters with its user-friendly interface. It caters to both individual and shared access needs. This guide demystifies what it takes to move from Dashboard to Headlamp, equipping users with the information they need for a successful shift.

Continue reading on kubernetes.io

#reading-list #tools #best-practice #devops #kubernetes

🔗 Markdown support coming in NetNewsWire

2026-08-06T08:00:00Z

NetNewsWire is about to embrace source:markdown elements in its next release. This move makes it the first mainstream RSS client to fully support Markdown. The integration allows WordLand-written WordPress posts, which already feature the necessary RSS feeds, to be published and rendered in Markdown. Users can simply log into WordLand and start creating content that will automatically be displayed in NetNewsWire via this format. A GitHub thread has been initiated to address any questions regarding this capability.

Continue reading on daveverse.org

#reading-list #tools #announcement

🔗 Introducing Mishka Chelekom v0.0.9

2026-08-05T17:00:00Z

Mishka Chelekom v0.0.9 revolutionizes how AI agents interact with Phoenix UI. This release adds a built-in MCP server, enabling AI to utilize your components accurately. In addition, it boasts over 35 new headless components that are unstyled yet fully accessible, allowing complete design customization without sacrificing functionality. The new Kit allows users to reuse and restyle components easily without altering original code, preserving project integrity. With a growing community behind it and over 55,000 downloads, this version solidifies Mishka Chelekom's position as a powerful tool for developers looking to integrate AI effectively into their Phoenix applications.

Continue reading on mishka.tools

#reading-list #ai #phoenix

🔗 Kubernetes architecture

2026-08-05T13:00:00Z

Kubernetes isn’t just another container orchestration tool; it’s an essential piece of cloud-native architecture that transformed how applications are managed. Neo Kim and Ayaan explain Kubernetes architecture, breaking down its components like the control plane and worker nodes. They illustrate how Kubernetes operates as a distributed system, ensuring applications stay available and resilient even as demands change. The authors emphasize the importance of concepts like desired state versus actual state, highlighting Kubernetes’ ability to self-heal and maintain the system’s equilibrium. This article not only provides a solid foundation for understanding how Kubernetes works but also makes a compelling case for why mastering its architecture is crucial for modern developers and architects.

Continue reading on newsletter.systemdesign.one

#reading-list #development #devops #kubernetes

🔗 Best and worst software projects: What developers really think

2026-08-05T08:00:00Z

AI significantly accelerates software delivery, but human decision-making remains crucial. Engineers recently discussed the role of AI in their projects, emphasizing its ability to enhance speed without replacing critical thinking and strategic choices. The insights reflect a balanced perspective on technology's place in development processes, highlighting the importance of creativity and judgment. In a rapidly evolving tech landscape, understanding the boundaries of AI's capabilities is essential for developers who aim to leverage it effectively while retaining control over their projects.

Continue reading on shiftmag.dev

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

🔗 Prefer strict tables in SQLite

2026-08-04T17:00:00Z

Strict tables in SQLite avoid datatype issues by enforcing rigid typing, preventing common mistakes like inserting text into integer columns. By appending STRICT to a table’s definition, users ensure that type mismatches are not allowed during inserts and updates. In contrast to non-strict tables, which permit any type in any column, strict tables help maintain data integrity and clarity. This article highlights the advantages and limitations of using strict tables, including better validation and avoiding creating columns with invalid types. While strict tables might introduce some performance considerations, the author argues that the benefits in data integrity far outweigh the potential drawbacks. The preference for strict tables is supported by examples and a discussion on SQLite's flexible typing.

Continue reading on evanhahn.com

#reading-list #database #best-practice #sqlite

🔗 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

🐥 YellowDuck.be

🔗 Why Pogačar rides on a car tire brand

🔗 Your Dropbox is now a skill server

🔗 Kubernetes Dashboard to Headlamp: A Step-by-Step Guide

🔗 Markdown support coming in NetNewsWire

🔗 Introducing Mishka Chelekom v0.0.9

🔗 Kubernetes architecture

🔗 Best and worst software projects: What developers really think

🔗 Prefer strict tables in SQLite

🔗 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

Update `UserAuth` helper