🐥 YellowDuck.be

🔗 How AI text watermarking works: a visual guide

2026-09-28T08:00:00Z

A watermark in plain text may seem impossible, as text lacks pixels and metadata. However, Google has implemented text watermarking from Gemini, starting in 2024, with new Claude models marking text invisibly and resiliently as of August 2026. These marks reside in the choices between words, not within the characters themselves.

The process involves small word choices made by a model that rolls weighted dice among acceptable options. Each choice can secretly lean toward certain words using a key, which makes counting colored choices easier for detection. The text can still read normally, but marked sections show an imbalance when re-evaluated with the correct key. Even editing alters the marks, as they depend on unbroken runs of original text.

Detection remains private and needs the provider’s key, contrasting with unreliable AI style detectors. This method can indicate whether a text has been processed without confirming authorship. Overall, it highlights the ongoing battle in maintaining and detecting AI-generated information.

Continue reading on declaude.org

#reading-list #best-practice #ai

🔗 Elixir's GenStage demand (a visual explainer)

2026-09-27T13:00:00Z

GenStage is a powerful Elixir abstraction that manages data processing through a simple yet effective concept: demand. As articulated by Andrea Leopardi, the article delves into how GenStage enables efficient data flow between producers and consumers while tackling a common issue in concurrent systems—the problem of unbounded queues. The discussion begins with a real-world example involving message consumption from a queue, illustrating how demand controls the rate at which producers send data. By employing a simple demand structure, consumers can regulate their intake and prevent overwhelming the system. The examination highlights how demand helps manage resources and explores important parameters like max_demand and min_demand, which dictate the rhythm of event processing. With clear explanations and practical examples, the piece offers vital insights for those looking to harness the full potential of GenStage in their applications.

Continue reading on andrealeopardi.com

#reading-list #development #pattern #elixir

🔗 The Elixir hiring paradox: notes from ElixirConf EU 2026

2026-09-27T08:00:00Z

Three common hiring mistakes plague companies looking for Elixir engineers. Arjun Gillard shared insights from his lightning talk at ElixirConf EU 2026 in Málaga, emphasizing that successful hiring requires a clear definition of success in the first 90 days. He noted that recruiters often fail to recognize that volume of applicants doesn't equal quality, and that evaluating candidates based solely on years of experience in Elixir technologies like Phoenix and LiveView misses the more crucial aspect: an applicant's reasoning skills. With Elixir's talent pool being tight-knit and relatively small in Europe, word travels fast when companies implement poor hiring processes. Gillard's observations highlight the importance of thoughtful, community-driven recruitment strategies that engage with candidates' conceptual understanding rather than their memorized skills in the stack.

Continue reading on agtalent.co.uk

#reading-list #best-practice #elixir #announcement

🔗 Japan tried to build an operating system for the entire world, then the US government intervened

2026-09-26T17:00:00Z

There's an alternate history of computing where Windows wasn't the dominant OS. This article reveals how Japan's TRON project aimed to replace traditional file systems with a hypermedia document model, but U.S. government intervention labeled it a trade barrier in 1989. Designed by Ken Sakamura at the University of Tokyo in 1984, TRON included sub-architectures like BTRON for personal computing and ITRON for embedded systems. Despite the ambitious goal of integrating Japan's digital infrastructure, BTRON was ultimately sidelined. Its design features, like a unique document-centric interface and a character encoding system capable of supporting over a million characters, were years ahead of their time. ITRON, however, succeeded in becoming widely used in embedded systems, marking a significant yet often overlooked chapter in technology history and highlighting the impact of global market dynamics on innovation.

Continue reading on www.xda-developers.com

#reading-list #development

🔗 A struct is just a map with rules

2026-09-26T13:00:00Z

Elixir's structs are more than just advanced maps; they enforce rules that prevent typographical errors. When modeling data, like a user profile, using a map can lead to subtle bugs if a key is misspelled — Elixir won't catch it. Bruce Tate points out that structs enable you to define specific keys within a module, allowing the compiler to enforce structure and prevent mistakes. Each struct contains an extra __struct__ key that links it to the module's definitions, ensuring the correct framework is maintained. By contrasting maps and structs, Tate emphasizes that maps are useful for dynamic and flexible data, while structs are designed for fixed data types. This nuanced distinction helps developers make informed choices when structuring Elixir applications, aligning with best practices seen within Elixir's own modules. Using structs can significantly improve code reliability and clarity.

Continue reading on grox.io

#reading-list #development #best-practice #elixir

🔗 The reality of being a CTO

2026-09-26T08:00:00Z

What does being a CTO really entail? James Stanier reveals that the role is often misunderstood. It ranges from a hands-on founder writing code to a board-level executive. The unique challenges include balancing technology with business outcomes and navigating high-stakes conversations beyond engineering. Stanier emphasizes that a successful CTO must bridge the gap between technical prowess and executive responsibility. He shares insights on managing time between team collaboration and conversations with other functional leaders, which is crucial for operating effectively. The evolving nature of AI introduces additional complexities, as it shifts hiring practices and expectations. Ultimately, being a CTO requires strong financial acumen and the ability to prioritize organizational strategy over just technical excellence.

Continue reading on leaddev.com

#reading-list #development #ai

🔗 Full-text search at Contentful just got faster: Why it’s important and how we did it

2026-09-25T17:00:00Z

Full-text search in Contentful just got faster — we improved the median response time by 35%. This is the story of how we did it and why it's important.

Continue reading on www.contentful.com

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

🔗 Re: Linking Patchwork with Sashiko?

2026-09-25T13:00:00Z

On July 14, 2026, Linus Torvalds expressed strong opinions about the role of AI in the Linux kernel development process. He countered the notion of an anti-AI stance within the community, making it clear that AI tools, including LLMs, can enhance the work of maintainers rather than hinder it. Torvalds emphasized that dismissing AI outright fails to recognize its utility and that the kernel community prioritizes technological merit above all. He noted that while AI isn't flawless, its capabilities have reached a level where it is undeniably beneficial to the project. He urged contributors to embrace these tools and focus on how they can assist rather than complicate development workflows. Torvalds remains committed to a technology-driven approach for the kernel, rejecting any viewpoints based purely on ideological objections.

Continue reading on lore.kernel.org

#reading-list #development #ai #linux

🔗 Go 1.27 release notes

2026-09-25T08:00:00Z

Go 1.27 has arrived with significant toolchain, runtime, and library updates. It introduces support for generic methods, allowing methods to declare their own type parameters, promoting better data type encapsulation. The math/rand/v2 module now has a generic method signature. Additionally, the release enhances package tools like response file parsing for smoother builds, while deprecating support for bzr version control. In terms of testing and documentation, go test now performs a standard library version check by default, and go doc introduces new syntax for package documentation. It also brings improvements to memory allocation processes and introduces new profiling options, specifically for identifying leaked goroutines. Notably, the addition of new libraries, including encoding/json/v2 and crypto/mldsa, further enriches the Go ecosystem with modernized functionalities. With Go 1.27, programmers can expect an overall improved experience while maintaining compatibility with previous versions.

Continue reading on go.dev

#reading-list #golang #development #announcement

🔗 How Instacart built a modern search infrastructure on PostgreSQL

2026-09-24T17:00:00Z

In a previous blog post “Improving search at Instacart using hybrid recall”, we shared our progress on adaptively combining traditional full text search with embedding-based retrieval. Embarking on this journey required rethinking our search infrastructure to support hybrid recall while ensuring scalability and reliability. In this blog post, we will dive deeper into the architecture and engineering efforts that made this possible and lessons learned along the way.

Continue reading on tech.instacart.com

#reading-list #database #postgresql #devops

🔗 Building distributed systems in Elixir: Part 5 — Supervisor from scratch

2026-09-24T13:00:00Z

In the latest installment of his series, the article breaks down how to create a supervisor from scratch in Elixir, emphasizing the concepts of process links and exit signals. The author illustrates the implementation of a manual supervisor managing two worker processes, highlighting its ability to restart failed workers without affecting healthy ones. The restart policy is simplified to focus only on abnormal exits, mimicking some of the mechanisms provided by OTP without using its built-in features. Through concrete examples, the piece clarifies how to track child processes and respond appropriately to crashes while maintaining the system's resilience. This hands-on approach aids in understanding distributed systems, making the complexities of supervision more approachable for Elixir developers.

Continue reading on dev.to

#reading-list #development #pattern #elixir

🔗 Building distributed systems in Elixir: Part 4 — Process linking

2026-09-24T08:00:00Z

In this article, Krishnadaspc dives into the concept of process linking in Elixir, exploring how failure relationships affect processes. He explains that when a parent process and a worker process are linked, if one fails, the other can be impacted, which helps maintain system integrity. The piece showcases examples using spawn_link/1 and Process.flag(:trap_exit, true) to illustrate how to create and manage linked processes. It elaborates on how abnormal exits propagate exit signals and how they differ from normal exits. Readers learn the importance of managing these relationships for building resilient distributed systems.

Continue reading on dev.to

#reading-list #development #pattern #elixir

🔗 Building distributed systems in Elixir: Part 3 — Process monitoring

2026-09-23T17:00:00Z

What happens when a process dies in a distributed Elixir application? Instead of polling to check if a worker is alive, Elixir provides an elegant solution through process monitoring. This article guides readers through building a process monitoring system using the Process.monitor/1 function. It highlights how to receive notifications about process terminations without relying on supervisors or GenServers. Through practical examples, it demonstrates how to handle both normal exits and crashes effectively, ensuring that processes can monitor each other’s lifecycles seamlessly. By leveraging Elixir’s message-passing model, the author emphasizes that failure detection can be integrated into the communication flow of distributed systems, laying the groundwork for more resilient application architectures.

For real applications with multiple workers, it also outlines how to manage and track multiple processes using maps to correlate monitor references with worker identifiers. Ultimately, this part of the series sets the stage for exploring process links in the next installment.

Continue reading on dev.to

#reading-list #development #pattern #elixir

🔗 Building distributed systems in Elixir: Part 1 - Building a stateful process in Elixir without GenServer

2026-09-23T13:00:00Z

What if a counter could be a process instead of just a variable? This article introduces the concept of building stateful processes in Elixir without using GenServer, focusing on the underlying message-passing model. The author, Krishnadas, details the creation of a simple counter process using only basic constructs like spawn, send, and receive. The piece illustrates how multiple clients can interact with the counter while maintaining the integrity of its state. By allowing processes to own their state and communicate solely through messages, Elixir embraces a design that minimizes synchronization issues commonly seen in multithreaded environments. This foundational understanding prepares readers for the more complex topics of OTP and distributed messaging to be discussed in future articles.

Continue reading on dev.to

#reading-list #development #pattern #elixir

🔗 Your application is already an MCP server

2026-09-23T08:00:00Z

Today marks the release of tempest/mcp, a new package designed for integrating AI clients with Tempest applications via the Model Context Protocol (MCP). This tool allows support agents to interact seamlessly with tasks like updating tickets and checking application states without needing to build separate applications. With tempest/mcp, key functionalities are embedded within an application’s existing architecture, transforming classes into servers and simplifying backend intricacies related to dependencies and validations. The article describes a real-world use case: creating an AI-powered support desk using SQLite that facilitates various ticket operations. By leveraging Tempest's validation and dependency management, the package ensures that all interactions are smooth and consistent, paving the way for real-time integration of AI functionalities in applications. It's an exciting step towards enhancing how applications can leverage AI in operational workflows, even while still in its experimental phase.

Continue reading on tempestphp.com

#reading-list #database #ai #elixir

🔗 Your CI should be disposable

2026-09-22T17:00:00Z

Your CI should only schedule builds, not install dependencies. It promotes a disposable approach, allowing local runs with a simple command. The article highlights using tools like Docker, Nix, or Makefiles to keep the process streamlined. With a well-defined workflow like steps: name: Do the thing run: nix build .#, developers can maintain control over their builds. This method ensures delivery continuity, even when services like GitHub Actions encounter issues, urging engineers to think about alternatives.

Continue reading on oppi.li

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

🔗 Ten books that shaped how I think

2026-09-22T13:00:00Z

What foundational texts have fundamentally influenced an engineer's mindset? This article highlights ten impactful books, each shaping a crucial aspect of thinking in engineering and beyond. From John Ousterhout's A Philosophy of Software Design, which emphasizes hiding complexity through deep modules, to Joseph Weizenbaum's Computer Power and Human Reason, which critiques reliance on technology, these selections serve as a guide for bridging theory and practice. Readers will find valuable insights into systems thinking, design principles, and the communications challenges of software development. The author's personal connection to these texts makes them compelling reading for anyone looking to refine their approach to engineering and design.

Continue reading on www.birkey.co

#reading-list #development #best-practice

🔗 The case for tri-state dark mode toggles

2026-09-22T08:00:00Z

Adding a dark mode toggle often leads many developers to implement a simple binary switch. However, the article argues that this approach is flawed for user experience. A tri-state control—allowing options for system, light, and dark modes—provides clearer intent and avoids confusion. The author references a experience where he challenged existing conventions by polling users, which overwhelmingly favored the tri-state option. The drawbacks of two-state controls are highlighted, particularly when a user's OS automatically switches themes. By offering clarity over brevity, tri-state controls not only help users express their preferences more explicitly but also reduce unexpected changes in the interface. This article encourages developers to rethink how they approach dark mode toggles, emphasizing predictability and user intent.

Continue reading on www.bram.us

#reading-list #frontend #css #best-practice

🔗 1 million DB updates, 3 days, 200 lines of Go: A legacy rescue story

2026-09-21T17:00:00Z

A legacy PHP application faced daily failures, causing delays in marketing campaigns. Instead of a complete rewrite, the team opted for a minimal intervention using Go and RabbitMQ. By decoupling the request lifecycle, they managed to process user updates asynchronously without overwhelming the database. The solution, implemented in just 200 lines of Go, led to zero failures over 18 months, demonstrating the power of simplicity and idempotency in rescue scenarios. This article details the challenges faced, the design choices made, and the significant outcomes achieved. It's a practical case study that underscores the need for adaptive, low-risk solutions in legacy systems.
package main

import (
 "database/sql"
 "time"
)

func processBatch(messages []StatusMessage) error {
 // 1. Fixed batch size of 50,000 messages.
 batch := messages[:50000]
 // 2. Begin an atomic transaction. (ALL or NOTHING)
 tx, err := db.Begin()
 if err != nil {
 return err
 }
 defer tx.Rollback()
 // 3. Process updates within the transaction.
 for _, msg := range batch {
 _, err := tx.Exec(
 ` UPDATE users SET status = 'processed' WHERE id = $1 AND status = 'pending' `,
 msg.UserID)
 if err != nil {
 return err
 }
 }
 // 4. Commit the batch atomically.
 if err := tx.Commit(); err != nil {
 return err
 }
 // 5. Acknowledge messages to RabbitMQ ONLY after commit.
 for _, msg := range batch {
 msg.Ack()
 }
 // 6. Static Backpressure: Sleep for 2 seconds.
 time.Sleep(2 * time.Second)
 return nil
}

Continue reading on dev.to

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

🔗 The agent needs identity. The model does not.

2026-09-21T13:00:00Z

A support agent may need a customer's email address to perform a lookup, but importantly, the model does not require that information. This article delves into the challenges of maintaining this distinction throughout an agent's operations, especially as it starts calling tools. With a practical demonstration using a support agent built with Phoenix LiveView, OpenAI, and other tools, it explores how personal information can inadvertently escape through various application states and tool arguments. The author outlines strategies to protect identity relationships while allowing necessary data access for operations. By designing these safeguards, agents can operate effectively without exposing sensitive customer information to models. This ensures a balance between functionality and privacy, showcasing a modern architectural approach to identity management in applications.

Continue reading on hfiguera.github.io

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

🔗 Can’t touch the DOM? Reach for :has() to style any element

2026-09-21T08:00:00Z

Using third-party component libraries can speed up development but often limits styling flexibility. Andrew Spencer introduces the CSS pseudo-class :has(), which allows developers to style parent or sibling elements without modifying the DOM directly. This tool lets you style elements based on the presence of others, unlocking new possibilities in CSS design. It's particularly useful for handling components from libraries where custom styles might be challenging. For example, :has(.error) enables dynamic styles like changing the label color based on the error state of an input. With growing browser support, this feature heralds a new era for more straightforward styling adjustments in complex component libraries.

Continue reading on thoughtbot.com

#reading-list #frontend #css #html

🔗 Engineering judgment matters more than ever

2026-09-20T17:00:00Z

The rise of AI agents in software development raises a critical question: can technology replace human engineering judgment? In a recent article, the author's experience illustrates how coding methodologies have transitioned with the integration of AI tools like GitHub Copilot and Claude Code. They now spend 80% of their time relying on these agents, which handle implementation tasks autonomously, allowing engineers to focus on strategy and design. However, the article emphasizes that despite advancements, AI tools still fall short in areas requiring deep understanding and contextual awareness. Good engineering requires not just coding ability but also an awareness of existing solutions, organizational history, and collaborative decision-making. The article provides valuable insights into the delicate balance of leveraging technology while maintaining essential human oversight in engineering workflows.

Continue reading on boredhacking.com

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

🔗 APIs are 100x more important than five years ago, and still uncool

2026-09-20T13:00:00Z

APIs might be boring topics for casual conversation, but their significance has skyrocketed. Kin Lane reveals that APIs are now about a hundred times more crucial than they were five years ago, even as their visibility diminishes. While AI grabs the spotlight, it relies heavily on APIs for functionality, creating a paradox where APIs remain essential yet overlooked.

The shift is not just in importance but in audience too. APIs, once tailored for developers, are now increasingly designed for automated agents without human patience or context. This change demands more precise documentation and clearer structures, removing the leeway humans once had. Lane argues that while the industry may overlook APIs, their foundational role will only grow, making those who invest in their infrastructure the real winners in the future.

Continue reading on apievangelist.com

#reading-list #best-practice #http #ai

🔗 A deep (and fuzzy) dive into search

2026-09-20T08:00:00Z

How does fuzzy search transform how we match terms in data? This article by Andrey Abramov unveils the inner workings of fuzzy search algorithms like Levenshtein automata and n-gram similarity. Initially launched in SereneDB six years ago, the article revisits the foundational algorithms that enable approximate matching in a new SQL-focused environment. It highlights the need for fuzzy search in handling unstructured text across fields from linguistics to bioinformatics, emphasizing its importance in deduplication scenarios. The author clearly explains how the Levenshtein distance defines similarity measures, and describes the powerful automaton trick that optimizes searching for close matches. The journey through theory and implementation offers insights into the complexity of scaling fuzzy search algorithms effectively.

Continue reading on blog.serenedb.com

#reading-list #database #sql

🔗 How I use AI in 2026 (Coding, Writing, Learning, Assistant-ing)

2026-09-19T17:00:00Z

One of the best ways to learn how to use AI effectively is by observing a power user and experimenting with different technologies to discern genuine functionality from hype. In this follow-up to How I use AI (2025), Shrivu Shankar shares his latest interactions with AI tools. He details his coding and research projects, utilizing Codex and Claude Code without custom features to facilitate workflows. Shankar emphasizes the importance of initial prompts, stating that 95% of the code is generated in a single run.

For writing, he recognizes the growing challenge of distinguishing AI-generated text from genuine effort, opting for a human touch instead. He also transforms research papers into interactive HTML files to enhance learning experiences. Notably, Shankar's approach to personal assistants has evolved, focusing on efficiency and minimal interference, with the goal of reducing notification fatigue while maintaining productivity. His commitment to cost-effective subscription choices showcases a practical approach to leveraging AI technologies.

Continue reading on blog.sshh.io

#reading-list #development #frontend #tools #ai