🐥 YellowDuck.be

🔗 Feature flags without a SaaS: How OnRotation gates features

2026-09-29T13:00:00Z

OnRotation is streamlining feature deployment without traditional SaaS solutions. By leveraging Elixir and Phoenix, the team implemented a customized feature flag system using a simple table and a function, rather than integrating a more complex library like FunWithFlags. With a small user base and known testers, the solution simplifies control by allowing specific features to be turned on or off for individuals without requiring a full redeployment of the app. Each flag consists of a unique name, description, and a list of allowed emails, making it both straightforward and manageable. The author emphasizes that this approach fits naturally into the context and architecture of the app, showcasing how a small team can effectively meet their needs without overcomplicating the system.

Continue reading on nickstalter.com

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

🔗 Do we still need build tools?

2026-09-29T08:00:00Z

How necessary are build tools for frontend development in 2026? The article raises crucial questions about their relevance, particularly for CSS and JavaScript. It examines the effectiveness of tools like Autoprefixer, esbuild, and Lightning CSS for managing vendor prefixes and syntax lowering. While some CSS features have become standardized, tools still provide value in combining files and minifying code. The discussion extends to JavaScript, where module bundlers like Webpack and esbuild are highlighted for their performance advantages, despite potential downsides in caching. With HTTP/2 and HTTP/3 changing the landscape, the necessity of bundlers is increasingly debatable. Ultimately, the article argues that build tools still play an essential role, although there are viable no-build alternatives for smaller projects or specific cases.

Continue reading on olliewilliams.xyz

#reading-list #javascript #development #frontend #css #tools

🔗 PostgreSQL for everything

2026-09-28T17:00:00Z

Contrary to popular belief, the answer to everything is not 42—it’s PostgreSQL. This article by Dr. Raphael A. Bauer outlines the power and versatility of PostgreSQL, showcasing its use throughout his two-decade career starting in 2003. He highlights its strengths such as being rock-solid, easy to install and scale, and simplifying IT setups by effectively replacing multiple systems. PostgreSQL's features allow it to function not only as a traditional database but also as a full-text search engine, document storage, and much more. Dr. Bauer discusses various plugins like TimescaleDB and pgvector that extend PostgreSQL’s capabilities, making it suitable for high volume web analytics, AI workflows, and even non-persistent caching. By examining these advantages, he advocates for considering PostgreSQL before looking for other technologies to address new requirements or challenges.

Continue reading on www.raphaelbauer.com

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

🔗 Bun 1.4 Rust rewrite is not looking good

2026-09-28T13:00:00Z

Bun, initially a promising project, has faced turmoil during its transition to a Rust-based architecture. Over the past three months, communication has deteriorated into vague promises about version 1.4, with repeated delays frustrating users. Citing over 5,000 open pull requests and heavy reliance on AI, the article highlights concerns about the coding practices adopted during this rewrite. Jarred's initial capabilities drew admiration, but scrutiny has grown as the codebase has shown signs of instability. The expectation that AI could seamlessly upgrade Bun's architecture may be misplaced, raising important questions about the future of AI in software development. As users await the next stable release, the sentiment is clear: perception can shift quickly, and trust can erode even faster.

Based on interviews, many believe that the decision to abandon Zig may have been more about promoting AI capabilities than meeting user needs. With no release in sight, the once-solid foundation of Bun feels precarious.

Continue reading on tipiirai.com

#reading-list #rust #development #ai

🔗 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

🔗 ID design and primary keys, pt. 1

2026-09-27T17:00:00Z

Is your database design stunted by traditional approaches? Alexey Makhotkin delves into a refreshing take on primary keys and ID design. He highlights the importance of aligning primary key selection with business requirements rather than sticking to conventional database norms. Through engaging examples, he introduces the concept of external IDs and anchor IDs, demonstrating how they relate to database entities. Makhotkin also emphasizes the significance of immutable anchor IDs for unique identification, plus the nuances of using external IDs effectively, even those from outside systems. By analyzing a minimal content management scenario, he shows the logical modeling with integer primary keys and uniqueness constraints, setting a strong foundation for understanding primary keys in database design. Part two promises to further explore the complexities of composite primary keys, making this a must-read for database enthusiasts.

Continue reading on anchorsandlinks.com

🔗 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