🐥 YellowDuck.be

🔗 How to safely delete records in massive tables on AWS using Laravel

2026-07-11T13:00:00Z

When handling massive databases, like Flare's table with 1 billion records, a naive DELETE can lead to disastrous locks. A straightforward delete could halt your app for hours. Instead, employing a LIMIT can speed up deletions, releasing locks faster. However, AWS Lambda's 15-minute execution time limit complicates things, necessitating a job queue for longer processes. By using CleanTableJob, the deletion tasks can self-dispatch, ensuring they run smoothly without overwhelming the system. Additionally, implementing an atomic lock prevents overlapping jobs, offering a reliable setup for managing large tables. Overall, this approach effectively balances database integrity and performance, ensuring efficient record management on AWS.

Continue reading on flareapp.io

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

🔗 Add a second remote origin with Git

2026-07-11T08:00:00Z

Sometimes you need a second remote origin for a project, especially if it involves auto deployment and access limitations. Hamid Shoja outlines the steps to add a second remote origin in Git where syncing with the primary origin is crucial. The process begins by using git remote add to add the additional origin, followed by using git push --all to push changes to both remote repositories. The article also highlights how to sync changes between the two origins with commands like git fetch and git merge, ensuring that both repositories remain aligned. This is particularly useful for developers needing flexibility in managing their code with multiple repositories.

Continue reading on dev.to

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

🔗 Why dead code feels hard to delete

2026-07-10T17:00:00Z

It’s a common challenge when developers hesitate to delete dead code, often due to the sunk cost fallacy or loss aversion. The sunk cost fallacy leads us to believe that since we invested time and effort into writing code, it holds inherent value. However, this line of thinking can lead to increased complexity and future costs. The loss aversion principle further complicates matters, as losing code feels worse than never having it at all, even if it's unused. Understanding these cognitive biases sheds light on why teams cling to dead code and emphasizes the need to view code as a liability, not a resource. Minimizing unnecessary code leads to more clarity and lower maintenance costs, ultimately helping teams serve their customers better.

Continue reading on www.germanvelasco.com

#reading-list #development #best-practice

🔗 Docker alternative: Podman on Linux

2026-07-10T13:00:00Z

Podman presents a compelling alternative to Docker, especially for Linux users. This article outlines how Podman operates without a central daemon, making it more secure and flexible by allowing rootless container execution. Readers learn the straightforward installation process, using common commands like podman run and podman ps, and the benefits of managing containers through systemd with Quadlets. Comparisons with Docker show Podman’s advantages, particularly in security and alignment with Linux philosophy, while also acknowledging Docker’s extensive ecosystem. It's a practical guide for anyone considering a switch or starting containerization on Linux systems with a focus on efficiency and improved security.

Continue reading on linuxblog.io

#reading-list #devops #linux #docker #sysadmin

🔗 Six SQL patterns I use to catch transaction fraud

2026-07-10T08:00:00Z

Fraud detection largely relies on SQL rather than machine learning or hype-driven technologies. The author shares six effective SQL patterns applicable to various transaction systems, from credit cards to e-commerce. The first pattern addresses velocity, identifying rapid usage of a stolen card, suggesting fraud. The second pattern, impossible travel, flags transactions occurring in far-apart locations within an implausibly short time frame. Another pattern identifies amount anomalies where specific transaction amounts correlate strongly with fraudulent behavior. The article also highlights suspicious merchants exhibiting unusual activity and off-hours spending, which indicates potential unauthorized use. Finally, a framework involving window functions allows for more complex fraud detection by aggregating signals from these patterns. The author notes that utilizing these patterns collectively enhances the ability to uncover fraudulent transactions effectively. This practical SQL-focused approach provides a foundation for building robust fraud detection mechanisms.

Continue reading on analytics.fixelsmith.com

#reading-list #pattern #best-practice #sql

🔗 Stop mounting your LiveView twice

2026-07-09T17:00:00Z

Every LiveView mounts twice on the first page load—once for the static HTTP "dead render" and again when the WebSocket connects. This can lead to unnecessary database queries and performance hits. The recommended fix is to use connected?/1 to conditionally load data during the connection, but this approach has its drawbacks. It still results in duplicate processing when mounting and can hinder SEO and user experience by leading to an empty first paint.

The article outlines the limitations of this conventional solution and highlights ongoing efforts by the Phoenix team to improve LiveView's handling of mounts via the adoption of LiveViews. This new approach aims to keep the LiveView process alive across connections, avoiding the need for multiple mounts altogether, enhancing performance and reliability. By addressing these challenges, developers can create more efficient LiveViews without compromising on initial page load quality or SEO prioritization.

Continue reading on elixirdrops.net

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

🔗 Stop programming in Markdown

2026-07-09T13:00:00Z

Amidst the rising hype around AI, particularly LLMs, companies misuse these tools in scenarios where traditional code is far superior. This translates to programming in Markdown, relying on LLMs to interpret logic with slow, costly, and insecure performance. Tasks often solvable with straightforward code are overcomplicated by using prompted LLMs. Examples like automating e-commerce returns illustrate a misuse of LLMs when simple code suffices. Additionally, the allure of LLMs often stems from their ability to simplify interactions, making them tempting despite their inefficiencies. The article emphasizes the need to resist using LLMs needlessly and to leverage traditional programming for common business processes. It calls for a reevaluation of when and how LLMs should be integrated into systems, pointing out the risks and inefficiencies of relying on them when simpler solutions exist.

Continue reading on structural.chat

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

🔗 Modern CSS theming with light-dark(), contrast-color(), and style queries

2026-07-09T08:00:00Z

This article dives into a novel dynamic theming system using new CSS features. It introduces light-dark() for switching between light and dark color schemes based on user preferences, while contrast-color() ensures optimal text visibility against varying backgrounds. The author combines these functions with @container style() to create customizable color palettes, enhancing both accessibility and aesthetics. Practical examples illustrate how to implement shadows in light mode and glowing borders in dark mode, ensuring that UI elements are visually appealing and readable irrespective of the theme. This innovative approach allows developers to craft intricate themes that respect user settings while providing a fluid user experience. Everything is browser-compatible as of May 2026, making this a timely exploration into modern CSS capabilities.

Continue reading on una.im

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

🔗 Mistral OCR 4 : SOTA OCR for Document Intelligence

2026-07-08T17:00:00Z

Mistral AI has released Mistral OCR 4, touting its ability to extract and structure content from documents with exceptional accuracy. This model supports 170 languages and is designed for self-hosted deployments, ensuring compliance and sovereignty. It introduces features like bounding boxes, block classification, and inline confidence scores, tackling the weaknesses of previous OCR generations. Human evaluations showed that independent annotators preferred OCR 4, achieving a win rate of 72% against leading systems, while delivering an impressive overall score on OlmOCRBench (85.20). The model facilitates enhanced document processing for tasks like retrieval-augmented generation and agentic workflows, marking a significant step forward in document intelligence.

Continue reading on mistral.ai

#reading-list #tools #ai #devops

🔗 In memory of the man who put red and green squiggles under words

2026-07-08T13:00:00Z

Tony Krueger, whose contributions went largely unrecognized, passed away recently. He is best known for implementing the red and green squiggles in Microsoft Word that alert users to spelling and grammatical errors. These features transformed how people interacted with word processors, shifting from interruptive spell checks to an unobtrusive system that highlights mistakes as they occur. Krueger's work on various versions of Word helped pave the way for modern writing tools in nearly every application today. His innovative approach not only improved user experience but also earned him an unexpected moment of fame when Penn & Teller acknowledged his work. While often overlooked, Krueger's legacy continues to impact users across the globe every time they see a red squiggle beneath a misspelled word. The next time this happens, remember to thank Tony.

Tony also reverse-engineered and ported the game Chip’s Challenge to Windows, showcasing his technical prowess before his fame in word processing began.

Continue reading on devblogs.microsoft.com

#reading-list #tools

🔗 Key activities for sustainable engineering team

2026-07-08T08:00:00Z

What signals indicate it's time for managers to change their operational focus? In a compelling article, Dunya Kirkali breaks down the essential activities that engineering managers must prioritize for effective team management. The piece categorizes these activities into internal, boundary, and external groups, emphasizing that synchronization meetings, reflections, and planning sessions are key for internal cohesion. Managers need to be attuned to their team's momentum through regular retrospectives and syncs. Boundary activities, such as ops reviews and business reviews, ensure alignment with organizational goals while external activities—like market research and customer feedback—provide necessary context. This framework enables managers to know when to shift their attention, ensuring teams can deliver effectively without micromanagement. Managers are encouraged to focus not just on the tasks at hand but on the signals that reveal deeper insights about their team’s dynamics.

Continue reading on blog.incrementalforgetting.tech

#reading-list #development #best-practice

🐥 How to start and enable ClamAV service on Linux

2026-07-07T17:00:00Z

ClamAV is a powerful, open-source antivirus engine designed to detect malware, viruses, and trojans on Linux systems. If you have just installed it, you need to start its background services so that it can protect your system and keep its virus definitions up to date.

This guide will show you how to start, enable, and verify the ClamAV services using systemctl.

Prerequisites

Before running the commands, ensure you have:

A Linux distribution installed.
Administrative privileges (sudo or root access).

Step 1: Start the Antivirus Daemon

The primary service is clamav-daemon. This background process loads virus signatures into memory and handles on-access scanning. It also allows you to run high-speed scans using the clamdscan utility.

Run the following commands in your terminal:

Start the service:
```
sudo systemctl start clamav-daemon
```
Enable it to start automatically on boot:
```
sudo systemctl enable clamav-daemon
```
Verify that it is running correctly:
```
sudo systemctl status clamav-daemon
```

💡 Note: The daemon might take a few moments to change to an "active" status. This delay happens because it is loading a large database of malware definitions directly into your system's RAM.

Step 2: Start the Automatic Database Updater

An antivirus engine is only as good as its virus signatures. ClamAV uses a separate service called clamav-freshclam to look for and download the latest malware definitions automatically.

To get the updater running, execute these commands:

Start the updater service:
```
sudo systemctl start clamav-freshclam
```
Enable the updater to start on boot:
```
sudo systemctl enable clamav-freshclam
```
Verify the update status:
```
sudo systemctl status clamav-freshclam
```

Conclusion

Your Linux machine is now running ClamAV in the background with continuous, automated database updates. You can now safely run manual system scans or configure real-time protection.

#terminal #linux #sysadmin

🔗 Build a document processing workflow in 30 minutes

2026-07-07T13:00:00Z

Workflows is an orchestration platform for building, executing, and monitoring complex AI-driven workflows. It provides durable, fault-tolerant workflow execution backed by battle-tested distributed systems infrastructure, combined with a developer-friendly SDK.

In this tutorial, you’ll build an end-to-end medical document processing pipeline using three Mistral capabilities: OCR to read PDFs, Agents to classify documents and extract structured data, and Workflows to orchestrate the entire process reliably.

The pipeline takes any scanned medical PDF like a prescription, a hospital bill, or an imaging report and runs it through three steps: optical character recognition (OCR) to extract raw text, an AI agent to classify the document type with a confidence score, and a second agent to extract patient information and document-specific fields as structured JSON. Because it’s built on Mistral Workflows, each step is durable and fault-tolerant: if a worker restarts mid-execution, the workflow resumes where it left off instead of starting over.

You’ll also include a human-in-the-loop step: when the classifier’s confidence falls below a configurable threshold, the pipeline pauses and waits for a user to review and confirm the category before extraction continues. Mistral Workflows enables these long-running processes that can pause and resume based on external input, which is difficult to build reliably with a simple async queue or a chain of API calls.

Continue reading on x.com

#reading-list #pdf #development #ai

🔗 RBAC in Laravel: a practical deep dive

2026-07-07T08:00:00Z

Role-Based Access Control (RBAC) provides a structured approach to authorization that becomes essential as applications scale. It helps define clear permissions through roles rather than relying on individual user permissions. Wendell Adriel's article delves into designing a robust RBAC model within Laravel without the need for external packages. Readers can learn about critical concepts such as team-aware roles, permission inheritance, and the importance of constraints like separation of duties. The article also emphasizes the value of establishing a clear permission model before defining roles, which aids in creating a cleaner and more manageable authorization system. This practical guide includes implementation steps and insights into potential pitfalls, making it a must-read for developers looking to optimize access control in their applications.

Continue reading on wendelladriel.com

#reading-list #development #laravel #best-practice #auth

🔗 Building Go APIs with Huma, sqlc, and Goose

2026-07-06T17:00:00Z

Building an API with Huma, sqlc, and Goose showcases a streamlined stack that strikes a balance between structure and simplicity. The author emphasizes the effectiveness of writing SQL for the schema and queries, enabling automatic generation of Go code while avoiding complexities introduced by ORMs. The project layout, from database migrations managed by Goose to type-safe Go code generated by sqlc, demonstrates how each tool integrates seamlessly without unnecessary overhead. Huma simplifies API operation definitions and generates OpenAPI specifications directly from Go structs, ensuring the documentation stays aligned with the implementation. This approach drastically reduces onboarding time for new engineers while maintaining clarity and predictability in code execution, essentially providing a clean, efficient development workflow that encourages productivity without compromising on control or understanding.

Continue reading on blainsmith.com

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

🔗 Why your X2D II files look better on iPad than iPhone

2026-07-06T13:00:00Z

Have you ever wondered why X2D II files appear more vibrant on an iPad than on an iPhone? The difference is not just in display technology but in how your eye perceives images. Konrad Michels reveals that while the iPhone 17 Pro Max boasts a higher pixel density at 460 PPI compared to the iPad Pro M4’s 264 PPI, this alone doesn’t enhance image quality for X2D II reviews. The article explains that the larger screen of the iPad allows images to occupy a greater angular size on your retina, activating peak contrast sensitivity and revealing subtle tonal gradations. Essentially, the X2D II’s 100-megapixel files require that angular room to fully appreciate their depth and detail, an insight often overlooked in favor of pixel count. Ultimately, understanding this visual physics leads to better evaluation of medium-format photography.

Continue reading on blog.tonalphoto.com

#reading-list

🔗 Agentic RAG vs long-context LLMs: a 171-question benchmark on 30 long PDFs

2026-07-06T08:00:00Z

What happens when you evaluate agentic retrieval-augmented generation (RAG) against long-context LLMs? This article presents a rigorous benchmark of 171 questions asked across 30 long PDFs. The results highlight stark differences in performance between traditional RAG methods and long-context language models. The findings suggest that long-context LLMs excel at parsing complex documents, allowing for more nuanced responses. Data shows that while RAG can be effective, its reliance on external data sources may hinder performance on intricate queries. This comparison offers vital insights for researchers and practitioners considering which model to adopt for handling extensive textual information.

Continue reading on www.surfsense.com

#reading-list #pdf #ai #testing

🐥 Fixing Korean PDF rendering issues in Poppler on Ubuntu 22.04

2026-07-05T17:00:00Z

Poppler’s pdftoppm tool is commonly used to render PDFs into images for processing, previews, or conversion pipelines. On Ubuntu 22.04, the default Poppler version (22.02) can run into issues when rendering PDFs that contain Korean text, especially when fonts are missing or incorrectly substituted.

This post explains a practical fix that avoids upgrading Poppler entirely.

The problem

When rendering certain Korean PDFs with pdftoppm, the output may show:

missing characters (blank boxes or “tofu” glyphs)
incorrect font substitution
broken or unreadable text rendering

This is often not caused by Poppler itself, but by missing font configuration and CMap data required for CJK (Chinese, Japanese, Korean) text handling.

The root cause

Poppler relies on the system font stack and external mapping data:

Fontconfig: resolves font substitutions
CJK fonts: provide actual glyphs for Korean characters
Poppler CMap data: maps PDF encodings to Unicode correctly

On a minimal Ubuntu server installation, two key components are often missing:

poppler-data
CJK font packages such as Noto Sans CJK

The fix

Instead of upgrading Poppler, installing the correct font dependencies resolves the issue.

1. Install CJK fonts

sudo apt install fonts-noto-cjk fonts-noto-core fonts-unifont

2. Install Poppler CMap data

sudo apt install poppler-data

3. Rebuild the font cache

fc-cache -fv

Verify the fix

Re-run your rendering command:

pdftoppm input.pdf output

Korean text should now render correctly in the generated images.

Why this works

Poppler 22.x is capable of rendering CJK PDFs correctly, but only when:

the system provides appropriate glyph fonts
CMap mappings are available via poppler-data

Without these, Poppler falls back to incomplete or incorrect font substitution, leading to broken output.

When you actually need a newer Poppler

Upgrading Poppler is only necessary if:

rendering logic itself is broken (rare for CJK issues)
you need specific bug fixes or features in newer releases

For font-related issues, upgrading is usually unnecessary and introduces avoidable dependency complexity.

Conclusion

If you encounter broken Korean text rendering in pdftoppm on Ubuntu 22.04, the fix is typically not a Poppler upgrade but a missing font stack.

Installing fonts-noto-cjk and poppler-data resolves most cases immediately and keeps your system stable without rebuilding core libraries.

#pdf #best-practice #linux #sysadmin

🔗 Don't roll your own ...

2026-07-05T13:00:00Z

This article presents a critical viewpoint on modern web design practices, echoing a well-known principle in cryptography: "Don't roll your own crypto." The author emphasizes that while developers are free to innovate, they should avoid reinventing standard UI elements that users rely on. This is particularly vital for website functionalities like scrolling, link navigation, text selection, and form controls. The author recalls frustrating experiences with custom implementations that disrupt user familiarity and efficiency, citing specific design pitfalls in well-known platforms like GitHub. With concrete examples and a personal touch, this piece serves as a warning for developers to lean on tried-and-true practices, ensuring usability over novelty.

Continue reading on susam.net

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

🔗 Migrating from Go to Rust

2026-07-05T08:00:00Z

Out of all the migrations, moving from Go to Rust stands out as unique. It is less about speed or type systems, as Go already offers significant advantages in those areas. Instead, this guide, written by Matthias Endler, addresses the nuances of correctness guarantees, runtime trade-offs, and developer ergonomics. It targets backend services, highlighting where Go excels and the challenges developers might face when transitioning to Rust.

The piece meticulously maps Go patterns to Rust equivalents, explaining how Rust's borrow checker enhances safety. Endler emphasizes the importance of understanding the trade-offs involved, especially considering Go's strong community and tooling. Rust's advantages include zero-cost abstractions and stricter compile-time guarantees, making the migration worthwhile for teams burdened by Go's limitations in error handling and concurrency. The guide ultimately serves as a practical resource for Go developers contemplating this shift, offering insights backed by professional experience in both languages.

Continue reading on corrode.dev

#reading-list #golang #rust #development

🔗 Testing Go CLIs with testscript

2026-07-04T17:00:00Z

Have you ever wondered what happens when a command-line interface (CLI) is tested under real conditions? The article dives into the testing of the CLI eon, which schedules jobs using LLMs. It emphasizes the need for integration tests that mimic user behavior rather than relying solely on unit tests. The author shares a detailed exploration of using the testscript package to create robust tests that check command behavior while providing isolation from actual file systems and configurations.

By correctly setting up test scenarios, the eon CLI can add jobs, list them, and handle errors without affecting the user's actual environment. This methodology ensures that testing the CLI's performance and reliability is aligned with how users would typically interact with it. Through this approach, consumers of the eon CLI can have confidence in its functionality and robustness without the risk of disruptions from their local setups.

Continue reading on rednafi.com

#reading-list #golang #tools #testing

🔗 The 10x AI delusion & the real bottlenecks

2026-07-04T13:00:00Z

Is AI really going to create a 10x productivity boost for developers? Vasudha Prabhala argues that the real bottlenecks in software delivery are not the individual developer's capabilities, but the organizational structure and systems in place. The conversation shifts from merely generating code faster to understanding how the existing developer ecosystem struggles under pressure.

Prabhala highlights insights from Adam Bender at Google, emphasizing that as AI-generated code increases, existing approval queues, compliance checks, and communication frameworks can collapse under the load. With scenarios like agentic edit wars, where autonomous agents argue over code without human oversight, teams risk losing intellectual control. This could lead to a chaotic environment where testing and verification processes become overwhelmed, ultimately jeopardizing the integrity of software systems, especially in sectors like banking and healthcare. Leaders are urged to focus on strengthening their systems now to avoid a costly fallout in the future.

Continue reading on vasudhaprabhala.substack.com

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

🔗 CLI vs MCP vs API for AI agents: which integration method should you use?

2026-07-04T08:00:00Z

Different integration methods for AI agents can significantly impact workflow efficiency. Could choosing the wrong one create friction as your agents become more advanced? Whether it’s a Command-Line Interface (CLI), Model Context Protocol (MCP), or an Application Programming Interface (API), understanding the tradeoffs is essential.

The article provides a detailed comparison of these methods, revealing that CLIs often outshine the others—even in the age of APIs. They offer simplicity, speed, and are ideally suited for local tools. In contrast, while APIs enhance scalability and provide structured output, they introduce complexity. MCPs aim to standardize interactions between AI models and data sources but are still maturing.

This comprehensive breakdown helps determine which method fits best for your AI workflows.

Continue reading on www.mindstudio.ai

#reading-list #development #pattern #tools #http #ai

🔗 Elixir v1.20 released: now a gradually typed language

2026-07-03T17:00:00Z

Elixir has entered a new era with the release of version 1.20, where it has embraced gradual typing. This update allows for type inference and checks on existing Elixir code without the need for type annotations. It effectively identifies dead code and potential runtime errors, which enhances code reliability with minimal developer overhead. The dynamic type introduced offers compatibility and narrowing capabilities that enable precise type management without overwhelming false positives. This means that Elixir can adaptively learn and refine types as code executes, ensuring a better development experience while maintaining its dynamic roots. The collaborative effort involved notable institutions and promises future enhancements, ensuring that Elixir continues to evolve with robust type systems.

Continue reading on elixir-lang.org

#reading-list #development #elixir #announcement

🔗 5 faster ways to copy large or millions of files in Linux

2026-07-03T13:00:00Z

Copying files in Linux just got more efficient. Using the cp command may feel familiar, but it lacks essential features for handling large datasets.

The article showcases five alternative methods that significantly enhance speed and reliability.

From rsync, which supports resuming interrupted transfers, to pv providing progress indicators, these tools are built for performance. The article emphasizes how using parallel with rsync can drastically cut transfer times for directories filled with small files.

Each method is broken down with installation commands and usage examples, focusing on not just copying, but ensuring integrity with checksum verification.

Using these techniques, especially in critical environments, can save time and prevent costly errors.

Continue reading on www.tecmint.com

#reading-list #tools #best-practice #linux