Popular：
Virtualization DNS security formal verification reachability analysis compiler errors macro conflict web extension development framework Bitmap Graphics API inconsistencies All Tags

Category: Development

Simulating the Hand-Drawn 'Boiling' Effect with SVG Filters

2025-07-21
Simulating the Hand-Drawn 'Boiling' Effect with SVG Filters

This article details a method for simulating the 'boiling' effect, a common visual style in hand-drawn animation, using SVG filters. This effect creates the illusion of subtle movement by applying slight distortions to image edges. The author explains how to use the feTurbulence and feDisplacementMap filters to generate a noise texture and apply it to an image, and how to animate filter parameters with JavaScript to achieve the boiling effect. Interactive demos allow users to adjust parameters and observe the effect's changes. The author successfully uses simple SVG filters and JavaScript to simulate a realistic hand-drawn animation effect on the web.

(camillovisini.com)
Development

XMLUI: Web Development for the Rest of Us

2025-07-21
XMLUI: Web Development for the Rest of Us

XMLUI brings the ease of use of Visual Basic's component model to modern web development. Using simple XML markup, developers can build reactive, themed web apps without needing deep expertise in React or CSS. Pre-built components and declarative data binding simplify the process. Integration with LLMs further streamlines development, allowing for collaborative creation and easier maintenance. XMLUI aims to empower solution builders, enabling them to create UIs without needing specialized front-end expertise.

(blog.jonudell.net)
Development

Time-Based Logging Beats Count-Based Logging

2025-07-21

Logging strategy is crucial in software engineering. This article argues that time-based logging (e.g., logging every X seconds) is superior to count-based logging (e.g., logging every X messages) when processing many events. Count-based logging results in wildly varying log frequencies under different loads, potentially leading to too few or too many logs. Time-based logging maintains a consistent log rate, avoiding performance degradation from excessive logs or observability issues from insufficient logging. The author uses pseudocode examples and a cost-benefit analysis to support their argument, offering a fresh perspective on efficient logging strategies.

(johnscolaro.xyz)
Development

connmap: Visualize Your Network Connections on a World Map

2025-07-21
connmap: Visualize Your Network Connections on a World Map

connmap is an X11 desktop widget that displays the geographic location of your current network peers on a world map. It works on Wayland too! Installation is straightforward: clone the repo, install dependencies (listed in the README), and run the executable. Customize map size, position, and update interval. Currently supports only IPv4 and is primarily tested with i3wm.

(github.com)
Development desktop widget network visualization

Dynamic Programming: It's Not What You Think

2025-07-21

The term "dynamic programming" in algorithm studies often causes confusion. 'Dynamic' doesn't refer to its changeability, but rather to the planning aspect of 'programming', originating from the 1950s when engineers planned construction projects as 'process scheduling'. In computer science, dynamic programming means planning the order of sub-steps required to solve a problem. For example, computing the Fibonacci sequence, the 'program' is the sequence of steps to calculate fib(2) to fib(10) in dependency order. This can be planned top-down or bottom-up; the final plan is the same, and both are considered dynamic programming. Richard Bellman coined the term to avoid a Secretary of Defense's aversion to 'mathematical research', cleverly choosing 'dynamic programming' because the adjective 'dynamic' cannot be used pejoratively.

(www.vidarholen.net)
Development

GitHub Code Suggestion Application Limitations

2025-07-20
GitHub Code Suggestion Application Limitations

Applying code suggestions in bulk on GitHub has several limitations. Suggestions require code changes, cannot be applied to closed pull requests, subsets of changes, single lines with multiple suggestions, already applied or resolved suggestions, pending reviews, multi-line comments, or pull requests queued to merge. Additionally, some suggestions may be temporarily unavailable for application.

(github.com)
Development

GitHub Code Suggestion Application Limitations: Single Commit Constraints

2025-07-20
GitHub Code Suggestion Application Limitations: Single Commit Constraints

Applying code suggestions in bulk on GitHub has several limitations: suggestions cannot be applied if no code changes were made, if the pull request is closed, when viewing a subset of changes, if there is more than one suggestion per line, to deleted lines, if the suggestion has been applied or marked resolved, from pending reviews, on multi-line comments, or if the pull request is queued to merge. Additionally, there are instances of an error stating "You can’t perform that action at this time." for unknown reasons.

(github.com)
Development

From Arch Linux to macOS: A PhD Student's Lazy Config

2025-07-20

A computer engineer PhD student in neuro-AI research, after nine years of using Arch Linux, switched to a new MacBook Pro. The post details how they configured their new machine in a single day to resume their workflow. They used Nix as a package manager, AeroSpace window manager, and Raycast launcher, while retaining familiar tools like the zsh shell and Zed editor. While macOS's package management isn't as convenient as Arch Linux, they compromised for better hardware stability and user experience.

(yberreby.com)
Development macOS config Nix package manager developer workflow

10x Database Throughput with io_uring and a Dual WAL

2025-07-20
10x Database Throughput with io_uring and a Dual WAL

Building a complex database, the author experimented with io_uring and a dual WAL design to boost performance. Traditional WAL approaches (write-then-apply) bottleneck performance. By separating "intent to write" and "completion of write" into two WALs, and leveraging io_uring asynchronous I/O, a 10x throughput improvement was achieved. This design asynchronously writes intent, then completion records; recovery only applies operations with both intent and completion, ensuring data consistency. The author used Zig and the Poro project (an experimental key-value database) to validate this approach, highlighting the importance of hardware parallelism, batching, and flexible consistency models.

(blog.canoozie.net)
Development asynchronous I/O

Exploiting Coprocessors to Achieve Deterministic Kernel Exploitation on A9/A11 Devices

2025-07-20

An updated version of the Trigon kernel exploit has been released, expanding support to A9(X) and A11 devices. This blog post details the challenging techniques used to overcome KTRR limitations and find the kernel base address across different devices. The new approach leverages the IORVBAR register and coprocessors (specifically the Always-On Processor), manipulating coprocessor firmware to achieve arbitrary kernel read/write, ultimately bypassing kernel protections for successful exploitation on A9 and A11 devices.

(alfiecg.uk)
Development coprocessor

Go 1.24 Memory Leak Investigation: An Unexpected Discovery and the Swiss Tables Surprise

2025-07-20
Go 1.24 Memory Leak Investigation: An Unexpected Discovery and the Swiss Tables Surprise

After the release of Go 1.24, an unexpected memory usage increase was observed in a data processing service. Investigation revealed that a refactoring of a memory allocation function in the Go runtime inadvertently removed an optimization, causing unnecessary zeroing of memory during large object allocation, thereby increasing Resident Set Size (RSS). While Go runtime internal metrics showed no change, system-level metrics revealed a significant increase in memory usage. Collaboration with the Go community helped pinpoint and fix the issue. Surprisingly, Go 1.24's new "Swiss Tables" feature significantly reduced memory usage in high-traffic environments, offsetting the previous regression and even yielding additional memory savings.

(www.datadoghq.com)
Development

Rust's Borrow Checker: More Curse Than Blessing?

2025-07-20

Rust, lauded for its blend of speed and safety thanks to its borrow checker, faces criticism in this post. The author argues the borrow checker creates significant ergonomic problems, rejecting perfectly valid code due to overly conservative rules. Multiple examples demonstrate the unnecessary refactoring required. The post questions the overstated role of the borrow checker in Rust's safety, comparing it to garbage-collected languages like Python and Julia. While acknowledging the borrow checker's benefits in concurrent programming, the author contends its overhead in single-threaded contexts outweighs the advantages. Rust's strengths, such as its strong type system and rich standard library, are highlighted as the true reasons for its success.

(viralinstruction.com)
Development

Bypassing Specialization in Rust: A Clever Use of Function Pointers

2025-07-20
Bypassing Specialization in Rust: A Clever Use of Function Pointers

While developing a Rust FAT driver, the author encountered a roadblock: specialization, currently unavailable in stable Rust. After unsuccessful attempts using macros and generic enums, a clever solution emerged: leveraging function pointers to emulate specialization. While this approach introduces some performance and memory overhead, it offers a viable workaround for specific scenarios, avoiding reliance on unstable features. The author concludes by advocating for the stabilization of specialization, as it promises a more efficient and cleaner solution.

(oakchris1955.eu)
Development function pointers

Augmenting CLIs and APIs for LLM Agents

2025-07-20
Augmenting CLIs and APIs for LLM Agents

The author encountered limitations in existing command-line tools and APIs when using Large Language Model (LLM) agents for reverse engineering automation, especially with the small context windows of local models. APIs need to balance providing enough information to reduce tool calls while avoiding context window overflow. Solutions explored include improved docstrings, helper functions, and pre-commit hooks. Further improvements suggested involve wrappers that cache output, structure it, and report remaining lines, as well as shell hooks providing directory information. The author concludes that existing CLIs need LLM enhancements; perhaps even a whole set of LLM-enhanced CLIs or a custom LLM shell is needed to improve the user experience for LLM agents.

(www.notcheckmark.com)
Development CLI Tools

BorgBackup: Efficient and Secure Deduplicating Archiver

2025-07-20

BorgBackup (Borg) is an open-source deduplicating archiver combining compression and authenticated encryption for space-efficient storage and robust security. It supports various compression algorithms (lz4, zstd, zlib, lzma) and offers easy installation across multiple platforms (Linux, macOS, BSD, etc.). Backed by a large and active community, Borg provides mountable backups for convenient access and, crucially, remember to always check your backups!

(www.borgbackup.org)
Development

Backup: Beyond a Simple Copy

2025-07-20
Backup: Beyond a Simple Copy

The importance of data backup is often underestimated. This article, based on the author's experiences, recounts various data loss scenarios, emphasizing that backup is more than just a simple copy; it requires a comprehensive plan and strategy. It explores the pros and cons of full disk versus individual file backups and the crucial role of snapshots in ensuring data consistency. The author also shares their preference for a centralized backup server architecture and guiding principles for an efficient backup system, previewing subsequent articles detailing their FreeBSD-powered backup server setup.

(it-notes.dragas.net)
Development

Achieving Polymorphism with Dynamic Dispatch in Zig

2025-07-19

Zig, unlike many languages, lacks built-in interfaces. However, this doesn't preclude polymorphism. This article details a method for achieving dynamic dispatch polymorphism in Zig using vtable interfaces. This approach cleanly separates interfaces from implementations, requiring no changes to implementation types while enabling dynamic dispatch. It leverages function pointers to construct a vtable and uses an `implBy` function to connect implementations to the interface, effectively mimicking the functionality of interfaces in object-oriented languages. This allows storing different implementations in arrays or maps. While some boilerplate code is involved, the advantages are a clean, flexible, and reusable approach with minimal impact on implementation types.

(williamw520.github.io)
Development Polymorphism

Building Software with AI: A Four-Document System and the Everlasting Beginner

2025-07-19
Building Software with AI: A Four-Document System and the Everlasting Beginner

The author built Protocollie in four days using AI pair programmer Claude, not through expert coding skills but via four documents: Architecture Overview, Technical Considerations, Workflow Process, and Story Breakdown. This process, likened to "throwing spaghetti at the wall," highlights experimentation over planning, showcasing the changing landscape of AI-assisted programming. It reveals a shift in the programmer's role and embraces the uncertainty of this new era, where rapid technological advancement outpaces the accumulation of expertise.

(worksonmymachine.substack.com)
Development

Linux Secure Boot Facing Key Expiration: A Race Against Time

2025-07-19

Linux Secure Boot systems rely on a Microsoft key set to expire in September. This key signs the shim, the first-stage UEFI bootloader used to boot the Linux kernel. While a replacement key has been available since 2023, many systems may lack it, potentially requiring hardware vendor firmware updates. This poses extra work for Linux distributions and users. Updating firmware via LVFS and fwupd might be necessary, but isn't guaranteed to succeed; older BIOS systems may face space constraints, even requiring a BIOS reset. Vendor updates may also be problematic, with some manufacturers having lost access to their platform keys. Ultimately, disabling Secure Boot might be the only option in some cases.

(lwn.net)
Development

Software Engineer Needed: Building the Future of Neural Data

2025-07-19
Software Engineer Needed: Building the Future of Neural Data

Piramidal is seeking a software engineer to build and maintain the backend infrastructure for their groundbreaking neural data platform. This role involves close collaboration with ML engineers to deploy cutting-edge models and working directly with product and internal teams to solve critical problems. The ideal candidate has 5+ years of experience at a product-focused company, proficiency in Python and other backend languages, expertise in containerization (Kubernetes), relational databases (Postgres/MySQL), and web technologies (JavaScript, React). Piramidal is committed to using technology to enhance human potential and supports cognitive liberty.

(www.ycombinator.com)
Development

Why I Refuse to Use AI for Writing

2025-07-19
Why I Refuse to Use AI for Writing

An author shares his reasons for refusing to use large language models (LLMs) for writing. He argues that over-reliance on LLMs reduces originality, weakens independent thinking, and deprives writing of personalized deep thought and associations. He cites studies from MIT and the UK supporting the idea that LLMs can lead to cognitive laziness and reduced learning motivation. Furthermore, the author finds LLM-generated text lacks personality and emotion, failing to capture the unique associations and insights that arise during reading. This conflicts with his pursuit of a deep reading experience. He ultimately chooses to stick to independent writing, believing it's the only way to maintain authenticity and originality.

(lifehacky.net)
Development cognitive laziness independent thinking

Ilograph Team vs. Team+ Subscription Comparison

2025-07-19
Ilograph Team vs. Team+ Subscription Comparison

Ilograph offers two team collaboration diagramming subscription plans: Team and Team+. The Team plan supports up to 5 editors and 20 viewers, offering unlimited team diagrams, diagram history, and custom icons. The Team+ plan supports 6 or more editors, unlimited viewers, and adds premium features like single sign-on, diagram exports, API access, and shareable links. The best plan depends on your team size and need for advanced features.

(app.ilograph.com)
Development collaboration diagramming subscription plans

Microtriangles: The Real Killer of Rendering Performance, Not Poly Count

2025-07-19
Microtriangles: The Real Killer of Rendering Performance, Not Poly Count

The old lore about polygon count determining rendering performance is outdated. Modern rendering is significantly impacted by microtriangles. This article argues that tiny triangles (under 10x10 pixels) become exponentially more expensive to render because GPUs compute a full 2x2 pixel block even if the triangle only covers one pixel. The author suggests focusing on "wireframe view density", switching to lower LODs when the view gets close to solid, or using a single LOD with imposters for distant objects. Epic's Nanite technology tackles this by using compute shaders and screen-space shaders to minimize the cost of rendering microtriangles.

(medium.com)
Development LOD optimization

The 14KB Rule: Why Website Size Matters More Than You Think

2025-07-19

Why is a 14kB webpage significantly faster than a 15kB one? The answer lies in TCP slow start, an algorithm that governs how servers initially send data. This article explains how TCP ensures reliable data transmission and how slow start optimizes bandwidth usage. High-latency networks, like satellite internet, dramatically illustrate the impact: each round trip adds significant delay. The article advocates for minimizing website size to under 14kB or, at the very least, ensuring critical content is within the first 14kB for optimal user experience. While HTTP/2 and HTTP/3 are mentioned, they don't negate the importance of this principle.

(endtimes.dev)
Development

Wii U Boot1 Exploit: Data Recovery Leads to 'Paid the Beak'

2025-07-19

This post details how a team, through recovering data from destroyed Nintendo Wii U factory test SD cards, unexpectedly discovered and exploited a Boot1 vulnerability. WiiCurious gathered numerous damaged SD cards, and DeadlyFoez used expert soldering skills to repair and read the data. Reverse engineer Rairii found a Boot1 vulnerability within this data and developed an exploit called 'paid the beak,' capable of fixing most Wii U software bricks. Additionally, the team developed methods using a Raspberry Pi Pico and PICAXE 08M2 to mimic the factory-specific tool needed to trigger the vulnerability. This exploit provides a more accessible way to fix Wii U bricks, avoiding the need for console disassembly and soldering.

(consolebytes.com)
Development Data Recovery

Guix Impressions: A Nix User's Perspective

2025-07-19

A seasoned Nix user shares their experience trying out the Guix System. Guix, being a GNU system, prioritizes software freedom, requiring the use of nonguix for modern hardware support. The article focuses on architectural differences between Guix and Nix: Nix employs a modular design allowing flexible combinations of package versions, while Guix integrates all packages into a fixed profile, requiring a rebuild for updates. Documentation, performance, and init systems are compared, revealing Guix's superior documentation but slower performance; it uses Shepherd instead of systemd. Overall, Guix is an intriguing alternative but steeper learning curve demanding Scheme knowledge.

(tazj.in)
Development

Beyond cuBLAS and CUTLASS: A Novel Matrix Multiplication Kernel Engine

2025-07-19
Beyond cuBLAS and CUTLASS: A Novel Matrix Multiplication Kernel Engine

Matrix multiplication is central to modern computing, especially in AI where its speed directly impacts model capabilities. While hardware accelerators like NVIDIA's Tensor Cores are efficient, they lack flexibility. This paper introduces CubeCL, a new engine that generates optimized matrix multiplication kernels across platforms. CubeCL uses a hierarchical abstraction (Tile, Stage, Global, Batch Matmul) and various algorithms (Simple, Double Buffering, Ordered, etc.) to achieve this. It cleverly leverages GPU architectural features like plane-synchronous execution and coalesced memory access, employing techniques like double buffering to hide memory latency. Benchmarks show significant performance improvements on various GPUs (NVIDIA, AMD, and Apple Silicon), even surpassing cuBLAS and CUTLASS in some cases.

(burn.dev)
Development

Bitnami Public Catalog Overhaul: Migration to Secure Images and Legacy Repo

2025-07-19
Bitnami Public Catalog Overhaul: Migration to Secure Images and Legacy Repo

Bitnami's public catalog undergoes significant changes on August 28th, 2025. Debian-based images will cease generation and move to a Bitnami Legacy repository. Free images will be streamlined to hardened, secure versions, available only on the 'latest' tag at https://hub.docker.com/u/bitnamisecure. Production-ready containers and Helm charts will transition to Bitnami Secure Images, offering hardened OS, continuous security updates (SLSA Level 3), CVE transparency, SBOMs, compliance artifacts, and enterprise support. All existing images will move to the Bitnami Legacy repository (docker.io/bitnamilegacy) with no further updates or support. Users should update CI/CD pipelines and consider subscribing to Bitnami Secure Images for continued support.

(github.com)
Development Secure Images

ccusage: Analyze Your Claude Code Token Usage, Blazing Fast!

2025-07-19
ccusage: Analyze Your Claude Code Token Usage, Blazing Fast!

ccusage is a command-line tool for incredibly fast analysis of your Claude Code token usage and costs from local JSONL files. It offers daily, monthly, session, and 5-hour block reports, with features like live monitoring, date filtering, custom paths, and JSON output. Its tiny bundle size allows for direct execution without installation, supporting multiple models and cost breakdowns. Try it with `bunx ccusage`!

(github.com)
Development
1 2 … 38 39 40 42 44 45 46 … 214 215