🐥 YellowDuck.be

🔗 MapSets: A set that's secretly a map

2026-11-11T18:00:00Z

What if a set could be more than just a collection of items? In the article, Bruce Tate sheds light on MapSet, revealing its hidden map structure and how it utilizes maps for efficient membership checks. He explains that MapSet allows for quick lookups like traditional maps, but provides set functionality where order doesn't matter and duplicates are ignored. Readers learn how to create sets, check for membership, and effectively manage expected behaviors when working with MapSet, all while emphasizing the importance of the underlying map data structure. By understanding these concepts, developers can choose better data structures for various scenarios, enhancing both performance and clarity in their Elixir applications.

Continue reading on grox.io

#reading-list #database #best-practice #elixir

🔗 A modern web app in C

2026-11-11T14:00:00Z

The decline of CGI in web development seemed set in stone in 2004, but in 2026 it's being reconsidered. Corey Prophitt highlights how he successfully built and launched a modern web application using C and CGI, showcasing a minimalistic stack including OpenBSD, SQLite, and essential libraries like libcurl and libsodium. This approach emphasizes the advantages of simplicity, low overhead, and fewer dependencies, making it possible to deliver a robust product without the complexities of modern frameworks. Prophitt argues that writing a CGI application today is feasible and effective, allowing developers to lean on their knowledge of HTTP without the burden of additional APIs. The article offers a glimpse into how leveraging timeless technologies can yield practical, less risky solutions in contemporary development.

Continue reading on prophitt.me

#reading-list #development #database #tools #http

🔗 My AI policy

2026-11-11T09:00:00Z

What happens when developers grapple with LLMs and community standards? This article tackles the challenges of expressing a personal stance on AI, balancing professional tools with ethical concerns. The author shares his journey and reflections on using LLMs to complement his work while confronting the larger issues of AI company practices. He questions the morality behind mass training on public content, highlighting the disconnect between content creators and the companies that profit from their work. As the web community faces increasing scrutiny over technology choices, he advocates for building a supportive environment instead of shaming others for their decisions. Whether discussing the ethics of AI or the pressures of public opinion, the piece provides a candid insight into the current landscape of development and AI integration.

Continue reading on remysharp.com

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

🔗 I'm sorry, but you still have to think.

2026-11-10T14:00:00Z

DHH, the creator of Ruby on Rails, chose to rewrite Campfire Once from Ruby on Rails to Rust, relying on a developer to handle the Rust code due to his discomfort with it. This decision, along with rewrites in languages like Elixir and Go, offers insight into the challenges faced by those using AI agents for coding without understanding the code themselves. The results weren't promising; they highlighted the necessity of specificity in prompts, as many programming decisions come down to subjective choices. While Elixir's version stayed closer to the original Rails architecture, both rewrites exhibited significant trade-offs. Rust payments weak performance in certain aspects, including a low new post delivery rate under heavy load due to its limited broadcast channel capacity. The comparative analysis emphasizes that programming decisions are complex and a single metric doesn’t tell the whole story. Ultimately, it reinforces the importance of thoughtful coding practices and understanding the nuances of each programming language's features and limitations.

Continue reading on itsallaboutthebit.com

#reading-list #rust #development #ai

🔗 I've been the sole developer of a healthcare membership platform for 6+ years. Here's what it looks like.

2026-11-10T09:00:00Z

What does a healthcare membership platform look like after six years of sole development? Tim Kamanin shares insights from building a system that integrates member applications, payments, event management, and more using Django and Wagtail CMS. Initially created to address a pressing need, the platform has grown into a robust tool handling memberships, communications, and exams seamlessly. Key features include automatic status tracking, an internal email system, and independent management of events—allowing non-technical staff to efficiently handle operations. This article explains how Kamanin maintains a monolithic codebase with a simple frontend while staying attuned to every line of code and business rule. He highlights the advantages of being the sole developer: quick adaptations, clean code, and deep familiarity with the platform's architecture. A testament to streamlined software development in the healthcare sector, his experience illustrates the value of dedicated ownership in tech projects.

Continue reading on timonweb.com

#reading-list #development #database #best-practice #django #wagtail

🔗 Review fatigue is real. Here's what my team did about it

2026-11-09T18:00:00Z

Reviewing pull requests (PRs) can often take longer than writing the code itself. This phenomenon, highlighted by Ivan Pelivanovic, emphasizes that even as AI tools facilitate quicker coding, they don't necessarily streamline the review process. The increasing speed of code deployment can lead to an overwhelming volume of reviews, resulting in a state of review fatigue that teams struggle to manage. This article explores strategies some teams have implemented to tackle this issue, ensuring that code quality and thoroughness don't suffer in the rush to deliver results.

Continue reading on shiftmag.dev

#reading-list #development #best-practice #git

🔗 Why MCP was always a bad idea

2026-11-09T14:00:00Z

MCP was hailed as a necessary protocol when released by Anthropic in 2024, but the landscape has drastically changed. As LLMs became adept at executing code and autonomously calling APIs, MCP began to feel redundant. While it facilitated early integrations between AI models and external services, the evolution of these models means they can now interact directly with APIs without reliance on MCP, which often wraps existing services. The recent emergence of Cloudflare's Code Mode exemplifies how LLMs have outpaced the capabilities offered by MCP, composing scripts directly and omitting the need for intermediary servers. The article argues for a shift towards direct use of HTTP APIs and standard practices. Standardization could streamline interactions, making agents more efficient than ever before. Thus, embracing closure on MCP may very well be a strategic step forward in AI development.

Continue reading on maharship.com

#reading-list #http #ai

🔗 How I built Tjommi's backend

2026-11-09T09:00:00Z

Tjommi's backend integrates sophisticated data handling for tracking purchased products and claims. It processes varied formats like emails, PDFs, and screenshots into structured records. The article dives into the iterative development of this backend, documenting architectural choices and technological advancements spanning from 2019 to 2023. Key components include the use of receipt extraction, retailer integrations, and the introduction of AI for processing formats. The evolving modular architecture within a Laravel application ensures smooth functionality, while managing complexities tied to retailer behaviors. Overall, it highlights how continuous refinement and innovative technologies enhanced the claims process and improved customer experience.

Continue reading on helgesver.re

#reading-list #pdf #development #laravel #database #ai

🔗 Why we started building on the Django 6.1 alpha

2026-11-08T14:00:00Z

Divio chose to adopt the Django 6.1 alpha long before its official release to actively contribute to its development. This decision was driven by their commitment to the Django community and the compelling new features Django 6.1 promised, such as database-level delete options and enhancements in the admin interface. By testing the pre-release daily, they not only utilized its advancements but also identified and reported several bugs, aiding the refinement of the framework. Their hands-on approach ensured they were at the forefront of developments and equipped them with insights into the new functionalities. As a result, Divio can now encourage others to explore Django 6.1, showcasing the readiness and potential of the framework for production use.

Continue reading on www.divio.com

#reading-list #database #django #testing

🔗 Shadcn datatable filtering

2026-11-08T09:00:00Z

A good datatable filter is essential for improving user experience by allowing for quick and easy access to specific data within large datasets. The Shadcn datatable filtering blocks combine search boxes, condition builders, and category filters to enhance the usability of data tables. These features allow users to narrow down their search through options like free-text search, stackable condition-based filters, and date range selectors, all while maintaining a seamless front-end experience using React and Tailwind CSS.

Additionally, the blocks work harmoniously with both Base UI and Radix UI, making integration straightforward. Users can employ the Shadcn Builder to effortlessly drag and drop these blocks into their projects, streamlining the layout process without the need for manual coding. The article thoroughly outlines the capabilities and use cases of these filtering blocks, which are a standout in the Shadcn studio library for efficient data handling.

Continue reading on shadcnstudio.com

#reading-list #javascript #frontend #css

🔗 django-absurd: ceci n'est pas un queue

2026-11-07T18:00:00Z

django-absurd integrates a Postgres-native workflow engine into Django, allowing developers to run background tasks and durable workflows seamlessly. It utilizes Django's existing database connection, minimizing overhead and setup complexity. To get started, developers must ensure compatibility with Python 3.12+, Django 6.0+, and use the psycopg driver. After adding django_absurd to the INSTALLED_APPS, the database schema is migrated, and tasks can be written using Django's @task decorator. The article outlines a straightforward task loop, from enqueuing to result retrieval, and highlights the use of workflow contexts for reliable task execution with checkpoints and retries. Key functionalities include tasks, workflows, cron jobs, worker management, and monitoring, making it a versatile solution for task management in Django applications.

Continue reading on lincolnloop.github.io

#reading-list #python #database #django

🔗 Django and deployments

2026-11-07T14:00:00Z

What if Django had a streamlined deploy command? This article contemplates the future of Django deployments, building on insights from Will Vincent's recent talks and suggestions from the community. The author, who is also the maintainer of django-prodserver, proposes conceptual stages for deployment, breaking them down into manageable commands. Key commands might include manage.py init_deploy_env and manage.py productionize. While there are myriad deployment strategies, the focus is on establishing a common API in Django that can aid in automating essential processes. By examining existing packages like django-production, the author suggests a pathway toward simplifying deployment in Django projects, inviting community feedback on the potential for such innovations.

Continue reading on softwarecrafts.co.uk

#reading-list #best-practice #django #devops

🔗 Django: Serve a security.txt file

2026-11-07T09:00:00Z

When a vulnerability is found on a site, security researchers often struggle to find a reliable way to report it. The solution? A security.txt file, standardized in April 2022, which lays out how to communicate security issues. This article provides a comprehensive guide on implementing a security.txt file in Django, serving it over HTTPS, and ensuring it remains current through unit tests and a custom system check. A thorough implementation is demonstrated, including the required content fields like Contact and Expires, as well as the code needed to serve the file and validate its integrity. Maintaining an updated security.txt file not only aids communication but is crucial for any web application’s security protocol. Adam Johnson expertly covers these aspects to ensure your site is prepared for researchers looking to communicate vulnerabilities effectively.

Continue reading on adamj.eu

#reading-list #best-practice #django #testing

🔗 Speeding up migrations when using Django Tenants, in prod and in tests

2026-11-06T14:00:00Z

The slow nature of Django migrations can hinder production deployments, especially when using Django Tenants. With a growing platform and numerous tenants, Xelix found that running migrations could take excessive time. Mikuláš Poul introduces the django-tenants-smart-executor library, which optimizes how migrations are handled. It detects when there are no migrations to apply and skips the lengthy checks, drastically reducing migration times for both production and testing environments. Additionally, the library allows skipping irrelevant state migrations based on the schema, further enhancing efficiency. While suggesting best practices to streamline migration processes in a multi-tenant architecture, this article serves as a valuable resource for those seeking to improve their deployment speed and test setup when using Django Tenants.

Continue reading on www.mikulaspoul.cz

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

🔗 Django WebSockets with Daphne: A complete guide

2026-11-06T09:00:00Z

WebSockets facilitate real-time communication, offering persistent connections over a single TCP channel. This article provides a thorough exploration of implementing WebSockets in Django using Daphne. It addresses the advantages of WebSockets over traditional HTTP requests, particularly for applications needing instant updates. By maintaining an ongoing connection, WebSockets enable bidirectional data flow, making them essential for modern applications such as chat systems or live notifications. The guide outlines the steps to integrate Daphne, showcasing configuration requirements and code snippets to get started effectively. This is a must-read for developers looking to enhance their Django projects with real-time capabilities.

Continue reading on www.digitalocean.com

#reading-list #development #http #django

🔗 API response cache with Redis and ETags

2026-11-05T18:00:00Z

High-traffic REST APIs often suffer from repetitive expensive computation and database queries for read-heavy resources. Without caching, backend systems waste CPU cycles and network bandwidth serving identical responses to clients, causing higher latency and elevated infrastructure costs.

This script solves the problem by combining Redis server-side caching with HTTP ETags (Entity Tags). Server-side caching in Redis reduces backend execution times to near-zero for warm keys, while HTTP ETags enable conditional GET requests (If-None-Match). When a resource hasn't changed, the server returns a lightweight 304 Not Modified header with no response body, dramatically reducing bandwidth usage and client render latency.

Continue reading on www.valtersit.com

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

🔗 Blue-green deployment switcher script

2026-11-05T14:00:00Z

In zero-downtime deployment architectures, switching traffic between two identical environments—Blue (current live) and Green (new release)—is a critical operation. Performing this traffic switch manually via web server configurations or load balancer updates is prone to human error, slow to execute, and lacks immediate automated validation. If a newly deployed environment passes preliminary build steps but fails under actual runtime conditions, manual rollbacks can introduce significant downtime and service disruption.

This script solves the problem by automating the blue-green traffic cutover process. It verifies the health of the target environment before switching traffic, atomically updates the local web server reverse proxy (such as NGINX), validates the live router state after the switch, and automatically triggers an immediate rollback if the new live endpoint exhibits post-switch degradation.

Continue reading on valtersit.com

#reading-list #tools #best-practice #devops #testing #sysadmin

🔗 Environment variable injector for Docker run

2026-11-05T09:00:00Z

When running containerized applications locally or across testing and production environments, developers often need to inject configuration settings stored in key-value .env files directly into Docker containers. Passing environment variables manually using multiple -e KEY=VALUE flags quickly becomes tedious, verbose, and error-prone.

While Docker natively supports the --env-file flag, it can be rigid—it lacks support for dynamically overriding dynamic host environment variables, programmatically inspecting injected keys before execution, or combining variable injection with standardized container runtime parameters (such as automatic port mapping, container naming, and dry-run output). This script bridges that gap by providing a CLI tool that parses .env files safely using python-dotenv, injects key-value pairs along with host-level environment fallbacks, validates prerequisites, and executes a clean docker run command via standard subprocessing.

Continue reading on valtersit.com

#reading-list #python #tools #devops #docker

🔗 FastAPI background task queue with asyncio

2026-11-04T18:00:00Z

When handling long-running operations—such as PDF generation, audio processing, batch notifications, or web scraping—processing them synchronously inside a FastAPI route handler blocks the response and risks timing out the client's HTTP connection.

While heavy distributed task frameworks like Celery with Redis or RabbitMQ are standard for large systems, introducing external message brokers adds significant deployment and operational overhead for small-to-medium applications. This script implements an in-memory, decoupled background task queue directly inside FastAPI using Python's native asyncio.Queue. It provides background job scheduling, task status monitoring, failure isolation, worker concurrency controls, and clean shutdown handling without relying on external dependencies.

Continue reading on www.valtersit.com

#reading-list #development #python #best-practice #http

🔗 GitHub Actions manual trigger CLI

2026-11-04T14:00:00Z

Automating deployments across microservices or triggering remote CI/CD pipelines often requires firing off GitHub Actions workflows from outside the GitHub web interface. While GitHub provides the workflow_dispatch event for manual triggers, developers and DevOps engineers often rely on ad-hoc curl commands or manual browser clicks. This approach is prone to syntax errors, lacks validation, and makes it difficult to pass complex parameters or monitor run progress programmatically.

This script solves the problem by providing a production-ready command-line interface (CLI) to trigger GitHub Actions manual workflows (workflow_dispatch). It handles authentication, parses structured inputs, validates responses, and can optionally poll the newly created workflow run until completion—making it suitable for standalone developer usage, deployment scripts, or cross-repository orchestration.

Continue reading on www.valtersit.com

#reading-list #tools #devops #github #terminal

🔗 Found our Django app was losing 2 seconds per request to GIL and GC. Built an eBPF tool to catch it.

2026-11-04T09:00:00Z

We run Django + gunicorn + DRF in production. Our API latency was consistently higher than what our traces showed. OpenTelemetry showed database and third-party API time, but there were always 1-2 seconds unaccounted for.

I built an eBPF profiler that hooks into CPython from kernel space. Here's what we found in our Django app:

GIL contention from Django URL resolution. Django's URL resolver was holding the GIL while resolving routes. With a large urlconf, this added up. Since our URLs are static, we added URL caching and cut GIL wait by 80%.

GC gen-2 pauses. Django loads a lot of objects at startup (models, middleware, URL patterns). Gen-2 GC was walking 1.5M objects on each collection. We added gc.freeze() in our gunicorn post_fork hook. Worst-case GC pause went from 1.27s to 88ms.

Gunicorn handoff latency. Measures how long a request sits in gunicorn's queue before a worker picks it up. When workers are busy with GIL contention or GC, handoff time spikes. After our fixes, handoff dropped from seconds to single-digit milliseconds.

Off-CPU stacks. Found that a Kafka push in one of our DRF views was blocking the thread for 130ms. Invisible in OpenTelemetry because it wasn't instrumented. Our tool showed the full Python stack: views.py:post > sessions.py:post > socket.py:readinto.

The tool uses eBPF uprobes on CPython's take_gil/drop_gil and gc_collect_main. No code changes to your Django app. Just point at the gunicorn PIDs and it shows you everything.

CPython 3.11 only for now. Open source.

GitHub: https://github.com/deepanshu406/python-ebpf-profiling

Continue reading on www.reddit.com

#reading-list #development #python #tools #django #devops

🔗 MCP server design for a large internal API surface

2026-11-03T14:00:00Z

Mapping 200 internal REST endpoints to 200 MCP tools results in substantial overhead, adding 200 KB of JSON schema per request. With the update on 2026-07-28, traditional methods of dynamic tool registration are now prohibited. This article, authored by Marius Bughiu, discusses the three effective strategies that remain: curation, authorization-scoped tool lists, and a search-and-execute facade. All strategies were validated against the @modelcontextprotocol/server 2.0.0. It emphasizes the importance of curating the tool list and optimizing the serialization process to ensure efficiency. Measurable wire sizes confirm the impact of tool catalog size on performance, affirming that a leaner approach to tool management can drastically improve interaction times and reduce costs. The need for a proper caching strategy is also stressed, calling attention to potential pitfalls in implementing public cache scopes.

Continue reading on startdebugging.net

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

🔗 The AI-native SDLC playbook

2026-11-03T09:00:00Z

How can AI reshape the software development lifecycle? In this playbook by Louis Claxton, the transformation of the traditional SDLC into an AI-native approach is detailed. The article outlines how AI, specifically Claude, can streamline processes across all stages—planning, design, building, testing, deploying, and maintaining software. By shifting focus from a human-centric to an AI-assisted model, organizations can eliminate bottlenecks that currently constrain productivity. Claxton provides actionable insights through various stages of an AI-native SDLC, showcasing how to leverage AI for automated processes while keeping human oversight in critical areas. This playbook serves as a practical guide for enterprises looking to adopt AI in their software development workflows, challenging outdated practices and encouraging a more efficient, collaborative environment.

Continue reading on claude.com

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

🔗 Using UV for installing Wagtail

2026-11-02T18:00:00Z

In a recent article, Raphael Stolt shared his experience with uv, the swift Python package and project manager, for setting up Wagtail on his Ubuntu development box. He highlighted how uv simplifies the installation process and enhances the management of virtual environments. The guide walks through the commands needed to install Wagtail, set up a virtual environment, and start the server, ensuring a smooth transition for developers familiar with PHP tools like Composer. Stolt appreciates the speed and usability of uv, likening its impact on Python to that of Composer on PHP. His insights shed light on the growing capabilities of Python tooling, making it an appealing option for developers.

Continue reading on wagtail.org

#reading-list #python #tools #wagtail #linux

🔗 Nifty Django feature: Q() objects

2026-11-02T14:00:00Z

A nifty feature of Django that is often underutilized is the Q object, which allows developers to express complex SQL conditions. Q objects can be combined with filters to dynamically build queries, enabling more flexible and powerful database interactions.

For instance, when searching for pets that need treats, Q objects can help combine conditions easily. With an example implementation, a Pet model is shown that effectively uses the Q feature to find pets who are starving by checking treat statuses. Additionally, composing Q objects dynamically opens new ways to tailor queries based on user input or other dynamic variables.

Overall, understanding how to utilize and compose Q objects can significantly enhance querying capabilities in Django, reducing redundancy and streamlining how developers interact with the database.

Continue reading on www.better-simple.com

#reading-list #database #best-practice #django