🐥 YellowDuck.be

🔗 Running tasks in production with Elixir releases: RPC, eval, and remote

2026-10-06T17:00:00Z

How do you run tasks in a Phoenix app once it's in production? This article highlights the limitations of Mix in a production environment and introduces alternative commands like rpc, eval, and remote provided by Elixir releases. It details building a recurring task in a deployed app and running it through Potions, emphasizing the need to manage tasks effectively, especially for items like discounting stale inventory. The article walks through the creation of a Mix task to automate price adjustments, then transitions into deploying and managing tasks in a live environment. In doing so, it explains the server structure once deployed and illustrates how to run the necessary commands remotely or via the release management script. With practical examples, this guide is essential for developers looking to enhance their production deployment with Elixir.

Continue reading on potions.io

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

🔗 Engineers grieve a job that no longer exists

2026-10-06T13:00:00Z

Something is happening in engineering teams that doesn’t show up in sprint velocity or deployment frequency; it shows up in resignation letters. The best engineers are burning out not just because of workload, but due to a deeper identity crisis as they are transitioning from builders to overseers. AI-coding assistants are fundamentally transforming their roles, leaving them feeling like they are losing touch with their passion for actual coding. A study from Oregon State University highlights how AI adoption intensifies job demands, increasing burnout among engineers who once thrived on problem-solving. This article provides insights into these challenges and emphasizes the need for leaders to engage their teams in discussions about these evolving roles.

Continue reading on leaddev.com

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

🔗 Speeding up Elixir test suites

2026-10-06T08:00:00Z

Last week, a developer optimized their Elixir/Phoenix test suite, reducing runtime from 313 seconds to 64 seconds. Key improvements included making tests async, which dramatically increased concurrency. Previously, 134 of 940 test files were running asynchronously, harming performance. By flipping to ~830 async files, the process spent less time aggregating results and more time executing tests in parallel.

They also eliminated redundant work by moving pre-seeded database rows to the committed test database, which avoided unnecessary setup during each test and reduced test time significantly. Other optimizations included stubbing external API calls to prevent slowdowns, managing process-global state for safer async execution, and ensuring proper pool size configurations for concurrent database access. The article emphasizes measuring performance before and after changes and treating flaky tests as serious bugs that need fixing.

Continue reading on zarar.dev

#reading-list #database #elixir #phoenix #testing

🔗 Use Postgres as a simple task queue for Django 🐘

2026-10-05T17:00:00Z

Using Postgres as a task queue for Django offers simplicity and reliability. In a compelling case, a startup named Nomio adopted Postgres over traditional options like Celery and Redis due to its straightforward implementation and decreased likelihood of task loss. The article outlines how to set up Postgres as a task queue through Django in four easy steps: setting up Django, connecting Postgres, running the worker, and managing tasks. It highlights the critical features like easy monitoring through the Django admin and the built-in reliability of Postgres. Despite being slower than Redis, many find it adequate for their needs. For those wondering about alternatives, SQLite can also be used instead of Postgres. This user-friendly guide provides practical code examples to help developers implement their own task queues quickly.

Continue reading on tomdekan.com

#reading-list #development #database #django #postgresql

🔗 Create a Django and React app with auto-generated Django types

2026-10-05T13:00:00Z

Building a type-safe application is crucial, and this article presents an effective solution. By integrating Django with React using type-safety, changes in Django models automatically propagate to TypeScript components, eliminating runtime errors due to discrepancies between frontend and backend. The setup includes Django 5, Django Ninja for the backend, and React with TypeScript for the frontend. The article details the entire process from setting up your project environment to creating models, generating schemas, building type-safe API views, and implementing a React frontend. You'll learn to create a fully functional application with seamless type safety, enhanced code quality checks, and even testing configurations. This approach ensures robust development with compile-time guarantees, making refactoring easier as model changes are consistently tracked across both back and front ends.

Continue reading on tomdekan.com

#reading-list #typescript #development #frontend #django #testing

🔗 Postgres as queue

2026-10-05T08:00:00Z

Using Postgres as a queue can simplify architecture and reduce complexity. The article shares insights from a team that effectively implemented this strategy to minimize infrastructure issues and avoid the overhead of elaborate message brokers. By polling and processing tasks directly in Postgres, the team demonstrated that added database load is often minimal, with task handling times only slightly increasing. They provided a clear example from the energy sector, illustrating how single-row updates can efficiently manage task states. This approach negates many common pain points found in multi-container setups and accidental complexity in SNS/PubSub architectures. The implementation also allows for easy adjustments, such as retries and batch processing, making it a flexible option for many developers. Overall, the article presents a persuasive argument for reconsidering traditional queuing methods in favor of leveraging Postgres directly.

Continue reading on leontrolski.github.io

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

🔗 The simplest way to add Tailwind CSS to Django 💨

2026-10-04T17:00:00Z

What does it mean to add Tailwind CSS to a Django project? This article by Tom Dekan provides a straightforward guide on integrating Tailwind CSS into Django templates using the Tailwind CSS Standalone CLI. It emphasizes the importance of writing Tailwind code, which is then converted into standard CSS for production environments.

Dekan covers essentials, from installing Django to creating templates and setting up a Tailwind CSS watcher. He advises against using a CDN for live projects, citing its limitations. The guide walks readers through configuring the setup, coding necessary views, and managing styles efficiently. This resource is valuable for developers looking to modernize their Django applications with Tailwind CSS, leveraging its utility-first approach for a responsive design.

Continue reading on tomdekan.com

#reading-list #frontend #css #django

🔗 How to secure a Linux server: An evolving how-to guide for securing a Linux server

2026-10-04T13:00:00Z

An evolving must-read guide for anyone looking to secure their Linux server. With over 31,000 stars on GitHub, this resource covers essential hardening techniques, from linux-kernel-sysctl-hardening to configuring nginx. The guide is open-source and continually updated, making it suitable for both novices and seasoned sysadmins. Each section is concise and actionable, ensuring readers can implement security measures swiftly. It’s an essential toolkit for securing a Linux environment effectively.

Continue reading on github.com

#reading-list #best-practice #linux #sysadmin

🔗 Cluster singleton pattern

2026-10-04T08:00:00Z

The challenge of safely running a single instance of a process in a distributed Elixir cluster can lead to frustrating failures. In her latest article, Johanna Larsson shares insights into the cluster singleton pattern and how to manage globally unique processes using GenServer and the :global name. She recounts experiences from her startup days, involving Kubernetes rolling deployments, where nodes inadvertently caused each other to shut down due to a misconfigured Swoosh email adapter. As a solution, she introduces a SingletonManager pattern that prevents cascading failures by managing process restarts without global linking. This article is a must-read for Elixir developers navigating cluster complexities.

Continue reading on jola.dev

#reading-list #development #pattern #elixir #kubernetes

🔗 The dangers of the Single Global Process

2026-10-03T17:00:00Z

The Single Global Process (SGP) pattern, although seemingly elegant, introduces serious issues in distributed systems. Highlighted by the author, such as in the context of building Elixir applications, using SGP can lead to data integrity problems when scaling beyond a single node. The reliance on a long-running process to manage state can result in duplicate counters and inconsistent data, especially during network partitions or "netsplits." The article delves into the shortcomings of SGP, offering insights on its pitfalls and discussing potential partial solutions like Compare and Swap (CAS) operations. For anyone involved in Elixir or Erlang systems, understanding these challenges is crucial to designing reliable applications that can scale effectively. The emphasis is on the necessity of recognizing the fragile nature of SGP in favor of more robust distributed solutions.

Continue reading on keathley.io

#reading-list #development #pattern #elixir

🔗 Bug blindness

2026-10-03T13:00:00Z

Why do some programmers notice bugs that others completely overlook? This article dives into the phenomenon of bug blindness, where individuals fail to recognize issues in software that may be glaring to others. The author reflects on personal experiences, suggesting that familiar users become desensitized to failures, particularly in widely disliked software like Blackboard or even popular search engines. By pointing out flaws to others, they've found that it can alleviate this blindness, allowing more people to see and address issues. This notion extends beyond just software, touching on how people’s biases influence their perception of quality and effectiveness. In an age where LLMs can mimic typical user interactions, recognizing these blind spots could very well lead to better products and experiences for everyone.

Continue reading on danluu.com

#reading-list #development #best-practice

🔗 Building distributed systems in Elixir: Part 7 — worker pool

2026-10-03T08:00:00Z

How can a system efficiently handle many jobs without overwhelming its resources? This article introduces a custom Worker Pool built in Elixir, tackling the challenges of unbounded concurrency within distributed systems. It starts with the problems faced when a system has to manage a large number of jobs, emphasizing the need for a bounded concurrency approach to avoid resource exhaustion and CPU thrashing.

The worker pool manages a limited number of active workers, assigning jobs from a buffered queue as workers become available. By employing raw process primitives, the article breaks down the architecture, including the parent/client process, coordinator process, and worker processes. It provides complete implementations and execution traces, illustrating how this approach allows for effective task distribution while maintaining system stability.

Continue reading on dev.to

#reading-list #development #pattern #elixir

🔗 Is agentic AI just automation?

2026-10-02T17:00:00Z

Why are most agents merely flowcharts in disguise? In this insightful piece, Prashant Mudgal critiques the common misconception that agentic AI offers capabilities beyond advanced automation. He delineates a clear distinction: automation handles known unknowns, while agentic AI tackles unknown unknowns. Mudgal presents real-world scenarios, such as aviation maintenance and due diligence, to illustrate how true agentic AI can uncover unprecedented insights, unlike traditional automated systems. He warns organizations that their overly structured processes often suffocate the potential for genuine decision-making. Instead of beginning with predefined use cases, he suggests starting from exceptions observed in workflows. This article is not just theoretical; it is a call to look beyond flowcharts and embrace the chaos where real intelligence can thrive.

Continue reading on towardsdatascience.com

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

🔗 WebSockets vs. SSE should be about ordering and correctness

2026-10-02T13:00:00Z

When considering WebSockets and Server-Sent Events (SSE), event ordering and correctness are critical for user experience. For instance, a scenario might arise where user actions like adding or removing tags can lead to chaotic and misleading outcomes if events arrive out of order. The author emphasizes that while many advocate for SSE due to perceived simplicity, the real battle lies in ensuring correct event delivery, which can be better handled by WebSockets. WebSockets allow for bidirectional communication, preventing issues that plague SSE and Fetch interactions, where multiple streams could race against each other. The article concludes by asserting that regardless of the technology choice, the essential question remains: how to ensure events are processed in the correct order to avoid confusing users?

Continue reading on dashbit.co

#reading-list #frontend #best-practice #http

🔗 Balancing flex items with flex-wrap: balance

2026-10-02T08:00:00Z

When flexbox items wrap but result in an orphan item, designers often resort to media queries to fix layout issues. However, this can lead to a fragile design that breaks easily with content changes. With the introduction of flex-wrap: balance in Chrome 150, layouts can appear much more organized. This article provides various solutions to keep flex items balanced, especially in scenarios where they might break into orphan items. Solutions range from using container queries to applying flex-line-count, showcasing the versatility of modern CSS. Each technique addresses responsive design issues without relying solely on problematic media queries. The ease of using flex-wrap: balance can dramatically improve the aesthetics and functionality of web layouts, making it an exciting addition to a web designer's toolkit.

Continue reading on ishadeed.com

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

🔗 My HTML boilerplate in 2026

2026-10-01T17:00:00Z

What does an updated HTML boilerplate look like in 2026? Manuel Matuzović shares his revised foundation for HTML documents, detailing every crucial element along with its purpose. He emphasizes the importance of a correct declaration, character encoding with , and the significance of the lang attribute in ensuring accessibility. With JavaScript support growing, he also discusses using a no-js class to handle non-JS environments. The article covers essential features like viewport settings for responsive design and the growing necessity of manifest files for Progressive Web Applications (PWAs). With an eye on performance and SEO, Matuzović provides a detailed look at the modern expectations of an HTML structure, ensuring it remains efficient and user-friendly. For anyone looking to modernize their HTML approach, this article is a valuable resource for best practices and considerations in 2026.

Continue reading on www.matuzo.at

#reading-list #frontend #best-practice #html

🔗 Build htop for the web with Go + Datastar

2026-10-01T13:00:00Z

How does a backend-driven UI sound? Alex Pliutau showcases how to create an interactive web application using Go and Datastar, focusing on applications where state management occurs entirely on the backend. With Datastar’s hypermedia-first approach, developers can build applications like a monitoring dashboard for host metrics without the need for a complex frontend framework. By leveraging Server-Sent Events (SSE) for updates, it provides a streamlined way to push HTML patches directly from the server to the client. This enables real-time updates with minimal client-side logic. Pliutau dives into practical code examples, including the use of the gopsutil library for resource metrics, demonstrating how to efficiently implement this framework. It's a compelling alternative to traditional frontend frameworks for specific use cases.

Continue reading on packagemain.tech

#reading-list #golang #frontend #http

🔗 Anthropic's Claude now has a browser of its own

2026-10-01T08:00:00Z

Anthropic has unveiled that its AI assistant, Claude, now includes a built-in browser feature. This addition aims to enhance the assistant's capabilities by allowing it to access real-time information from the web. As AI integrates deeper into daily tasks, having a browsing capability could bridge the gap between static responses and dynamic data retrieval. The model can now provide more accurate, up-to-date answers, making it a more powerful tool for users. The development reflects a growing trend in AI where tools are being equipped with functionalities that extend beyond traditional limits. Will this feature redefine how users interact with AI? Only time will tell.

Continue reading on thenewstack.io

#reading-list #ai #announcement

🔗 Speeding up a Phoenix LiveView web app with a CDN

2026-09-30T17:00:00Z

Using a CDN can significantly enhance the performance of Phoenix LiveView web applications, especially those with dynamic content and user sessions. The article outlines an effective way to leverage bunny.net as a CDN, detailing a low-effort configuration that can lead to high rewards. It emphasizes caching strategies through Plug.Static and shows how to configure static asset serving from a CDN domain. By adjusting the static_url in your application's config and ensuring that asset links use the url helper, all your static files can efficiently be served from a designated CDN subdomain. Additionally, the article touches on the importance of optimizing outgoing traffic and page load speeds, making it a valuable resource for developers looking to improve their Phoenix LiveView applications with minimal overhead.

Continue reading on jola.dev

#reading-list #frontend #phoenix #devops

🔗 DuckLabs to join AWS, projects to remain open source

2026-09-30T13:00:00Z

DuckLabs has announced its upcoming partnership with Amazon Web Services (AWS), set to take effect in early September. This union is aimed at leveraging AWS’s resources and reach, while ensuring that the open-source initiatives underpinning DuckDB, DuckLake, and Quack remain available under the MIT license. The DuckDB Foundation will continue to oversee these projects, preserving the spirit of community contribution.

With over one million downloads daily, DuckDB has proven to be a crucial tool for developers worldwide. The move to join AWS is seen as a necessary step to scale the technology further, enabling DuckLabs to focus on technical advancements without compromising on the open-source ethos that fueled its success. This collaboration promises even greater opportunities for both the technology and its global community of users, contributors, and advocates as they enter this new chapter together.

Continue reading on ducklabs.com

#reading-list #database #devops #announcement

🔗 The Dutch community where people live on strips of land in a lake

2026-09-30T08:00:00Z

In the Dutch town of Loosdrecht, residents inhabit homes perched on slim islands within a lake. This distinctive living arrangement originated from peat mining that created narrow strips of land meant for drying peat. Though it remained a quirky geographical feature for years, the 20th century saw developers transform these strips into boat-access-only properties. Now, a community enjoys a unique lifestyle that blurs the lines between land and water, epitomizing innovation in how we think about living spaces.

Curious about this fascinating community? Check out the full article to learn more!

scheendijk

Continue reading on www.core77.com

#reading-list

🔗 Your executable is a SQLite database

2026-09-29T17:00:00Z

Can a SQLite database replace the traditional ELF executable format? In a thought-provoking exploration, Farid Zakaria delves into the potential of employing SQLite as a genuine executable, dubbed SELF (Structured Executable & Linkable Format). By leveraging SQLite's self-describing features, Zakaria argues that an executable format can not only be more efficient but also easier to work with. He demonstrates that key functionalities of ELF can be reimplemented through a relational structure, allowing tools and queries to operate seamlessly without cumbersome overhead. Zakaria's experiments show that this innovation could streamline program execution while simplifying the complexities typically encountered with ELF files, including dynamic linking and symbol resolution. This article is a detailed journey into a radical idea that blurs the lines between databases and executables, highlighting a forward-thinking approach to software architecture.

Continue reading on fzakaria.com

#reading-list #development #database #sqlite

🔗 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