Category: Development

Asahi Linux Bans Large Language Models (LLMs)

2025-07-28
Asahi Linux Bans Large Language Models (LLMs)

The Asahi Linux project has banned the use of Large Language Models (LLMs, referred to as 'Slop Generators' in the text) for any contributions involving code, documentation, or engineering decisions. This ban is based on several concerns: 1. Intellectual property risks: LLM training data may contain copyrighted material, leading to potential infringement when using LLM-generated code; 2. Resource waste: Training and inference of LLMs consume massive resources; 3. Limitations of LLMs: LLMs cannot guarantee the correctness of their output and are prone to generating misinformation. Asahi Linux argues that LLMs are not suitable software engineering tools and their use poses legal and technical risks, while wasting valuable resources.

Development

How to Inefficiently Build a Website: An Anti-Tutorial

2025-07-28

This article offers a paradoxical guide to website building, focusing on maximizing time and energy expenditure. Key strategies include: indiscriminately installing npm dependencies to create a web of dependencies; choosing a framework before needing one, ensuring continuous learning curves with updates; and always requiring a compilation step, adding extra build processes. In short, this is an anti-tutorial on how to waste time effectively in web development.

Development anti-tutorial

Conquering Meeting FOMO: Building a Culture of Effective Meetings

2025-07-28
Conquering Meeting FOMO: Building a Culture of Effective Meetings

This article tackles the pervasive problem of unproductive meetings, proposing a solution centered around a culture of efficient meetings. The author highlights the common issue of meetings lacking clear value, wasting both time and money. The proposed solution emphasizes using meetings primarily for brainstorming and group decision-making, while advocating for asynchronous knowledge sharing through written documentation. The author suggests detailed agendas, time estimates, and moderators to keep meetings focused and on track. Attendees should actively participate or, if appropriate, decline and access meeting minutes later. The author concludes with a personal anecdote highlighting the positive impact of this approach.

Development

The JavaScript Runtime Explosion: A Decade of Innovation

2025-07-28
The JavaScript Runtime Explosion: A Decade of Innovation

The past decade has witnessed an explosion of new JavaScript runtimes and engines, enabling JavaScript execution across diverse contexts with remarkable task-specific optimization. This has propelled JavaScript into the cloud, edge computing, smart TVs, mobile devices, and even microcontrollers. This article explores the drivers behind this diversity and why a single runtime or engine fails to meet all needs. From the rise of edge computing and low-resource engines for microcontrollers to polyglot engines facilitating interoperability with other languages and the widespread use in native app development, JavaScript runtimes demonstrate incredible adaptability and vibrant growth. The article details various runtimes and engines like Node.js, Deno, Cloudflare Workers, Bun, React Native, NativeScript, and more, outlining their underlying technologies and evolution.

Development Runtimes

GPLv2 Installation Rights: A Historical Clarification and Ongoing Dispute

2025-07-28
GPLv2 Installation Rights: A Historical Clarification and Ongoing Dispute

This article refutes the misconception that GPLv2 doesn't protect users' right to reinstall modified software. The author details FSF's (Free Software Foundation) handling of a GPL violation by TiVo in 2003 and clarifies the meaning of "scripts used to control compilation and installation of the executable" in GPLv2. He argues that FSF and Conservancy have long held that GPLv2 requires providing the information necessary to reinstall modified software, a position reaffirmed through communication with FSF. The author contends that conflating GPLv3's added requirements with GPLv2, along with misinterpretations of the TiVo case, have led to a misrepresentation of GPLv2 installation rights. He calls for a focus on users' rights to repair and reinstall software and opposes companies' misrepresentation of the GPL license for profit.

Development Software Freedom

Become a JJ VCS Master in 60 Minutes

2025-07-28
Become a JJ VCS Master in 60 Minutes

Tired of Git's complexities? This isn't another blog post praising JJ; it's a fast-paced workshop designed to get you up to speed with the JJ VCS quickly. Through a series of eight concise exercises, you'll master core workflows—from creating commits to resolving merge conflicts in stacked PRs—in just 1-2 hours. Created by Dr. Jimmy Koppel, this workshop offers simulated scenarios to provide hands-on experience and boost your version control productivity.

Development Git Alternative

Recursive Descent Parsers: Simple Wins Over Complexity?

2025-07-28

The author explores approaches to parsing computer languages, specifically comparing recursive descent parsers to LR parser generators. While LR parser generators handle more complex grammars, the author favors recursive descent parsers due to their ease of use, lack of reliance on external tools, and ability to be written directly in the target language, thus minimizing learning curve and debugging challenges. For developers who occasionally need to build parsers for small languages, the simplicity and ease of use of recursive descent parsers outweigh their limitations in handling complex grammars.

ZUSE: A Sleek IRC Client for Your Terminal

2025-07-28
ZUSE: A Sleek IRC Client for Your Terminal

ZUSE is a minimalist IRC client built with Go and the Bubble Tea framework, offering a fast, clean, and distraction-free chat experience directly from your terminal. Installation is simple: `go install github.com/babycommando/zuse@latest`. The software is under active development, so be aware of potential bugs and missing features.

Formal Specifications: Beyond Instructions, Defining Software Behaviors

2025-07-28
Formal Specifications: Beyond Instructions, Defining Software Behaviors

This post delves into the distinction between formal specifications and traditional programs. While programs are lists of instructions, formal specifications are sets of behaviors. Using a counter example, the author illustrates how specifications define all correct behaviors and leverage set theory, employing generators (Init and Next) to describe infinite sets of behaviors. This contrasts with the concept of nondeterminism in programming; in formal specifications, nondeterminism refers to multiple ways a behavior can be extended, while in programs, it refers to uncertain code paths. The article emphasizes understanding formal specifications as sets of behaviors, crucial for debugging and interpreting model checker errors.

Blazing Fast Cuckoo Filter Lookups in C# with Bit Twiddling

2025-07-28
Blazing Fast Cuckoo Filter Lookups in C# with Bit Twiddling

While implementing a Cuckoo Filter in C#, the author significantly optimized lookup speed by cleverly replacing a 4-byte bucket with a 32-bit integer and employing bit manipulation tricks. Initially, a byte array required looping through four bytes per bucket. Switching to a uint array and using bit shifting improved performance by roughly 35%. However, the author's final optimization, a branchless bit manipulation technique to directly check for a target byte, resulted in over 60% faster positive lookups and more than double the speed for negative lookups. While readability decreased slightly, the performance gains are substantial, making this a worthwhile optimization strategy.

Development

Claude Code Router: Unleash the Power of Multi-Model AI Access

2025-07-28
Claude Code Router: Unleash the Power of Multi-Model AI Access

A powerful tool to route Claude Code requests to different models and customize any request. It supports multiple model providers like OpenRouter, DeepSeek, Ollama, Gemini, and more, allowing customization of requests and responses via transformers. Users configure models flexibly through a config file, enabling dynamic model switching, GitHub Actions integration, and a plugin system. This significantly enhances Claude Code's flexibility and efficiency, especially for scenarios needing model switching or request/response customization.

Development

How to Make PostgreSQL Ridiculously Slow?

2025-07-28
How to Make PostgreSQL Ridiculously Slow?

This article challenges the reader to make PostgreSQL as slow as possible by tweaking parameters in the `postgresql.conf` file, without resorting to CPU throttling or index deletion. Through a series of carefully chosen adjustments, including drastically reducing the buffer cache size (`shared_buffers`), aggressively triggering autovacuum and analyze (`autovacuum_*` parameters), and configuring WAL (`wal_*` parameters) for maximal write frequency and I/O contention, the author manages to reduce PostgreSQL's TPS by over 7000 times, from 7000+ to below single digits, even under 0.1 TPS. The author details the rationale and impact of each parameter change and provides a reproducible configuration. This is a fascinating experiment showcasing the profound impact of database parameter tuning.

Development Parameter Tuning

Rescuing My Blog's Performance with jekyll-skyhook

2025-07-28
Rescuing My Blog's Performance with jekyll-skyhook

My blog's Google indexing failed, and PageSpeed Insights gave a dismal 43/100. The culprits? Google Fonts, YouTube embeds, and poorly optimized images. I built a Jekyll plugin, jekyll-skyhook, to fix this. It self-hosts fonts, uses a lightweight YouTube library, and implements image transformations, responsive images, and caching. The result? A soaring PageSpeed score of 99/100! jekyll-skyhook supports image format conversion (WebP, AVIF), automatic srcset generation for responsive images, and caching to avoid redundant processing, significantly boosting blog performance.

Development

Coding at 800 WPM: A Blind Developer's Journey

2025-07-28

This article details the experiences of a blind software developer who uses a screen reader to code at an astonishing 800 words per minute. The author navigates the challenges of screen reader usage, explaining his choices of Windows and VS Code, and offering insights into handling images, diagrams, and team collaboration. He shares techniques like using IaC, LLMs, and custom userscripts, highlighting the crucial importance of accessible developer tools. The article underscores the developer's remarkable adaptation and the need for better accessibility in the software industry.

Multiplex: Command-Line Parallel Process Manager

2025-07-28
Multiplex: Command-Line Parallel Process Manager

Multiplex is a command-line tool with a simple Python API to run multiple processes in parallel and stop them all at once, or based on a condition. It gracefully shuts down child processes, multiplexing their output and error streams to stdout and stderr for easy parsing with standard command-line tools. Multiplex is useful for running multiple programs concurrently and combining their output, such as a web server, work queue, and database. It supports named processes, delayed starts, process- or time-based dependencies, and actions like silent mode and terminating other processes on completion. With its concise syntax, Multiplex simplifies complex orchestration, including CI/CD pipelines and development environment setup.

Development process management

Hacking My Washing Machine: A Discord Notification Odyssey

2025-07-28
Hacking My Washing Machine: A Discord Notification Odyssey

A group of university students, for fun and practicality, hacked a cheap smart washing machine. Using network sniffing, they discovered the machine communicated with its app via simple HTTP, using a basic XOR encryption. Through reverse engineering and brute-forcing the encryption key, they accessed the machine's status and created a script to update it to their Discord server. The process was challenging and fun, showcasing their skills. They plan to apply this to other appliances for a fully automated smart home.

Development

Blender on Tablets: 3D Modeling Goes Mobile

2025-07-28
Blender on Tablets: 3D Modeling Goes Mobile

Blender is expanding to tablets! The team is bringing the power of Blender to iPad Pro (initially), adapting the UI for touch and stylus input. The focus will be on core features like object manipulation and sculpting, later expanding to more advanced tools. While targeting tablets, improvements will also benefit desktop users. The project is open for contributions, and demos are planned for SIGGRAPH 2025 and the Blender Conference 2025.

Development tablets

DumbPipe: A Configuration-Free Inter-Computer Pipe

2025-07-28

DumbPipe establishes a secure data pipe between two computers with a single command, requiring no accounts or configuration. The receiver runs `./dumbpipe listen` to obtain a key. The sender uses this key with `./dumbpipe connect` to transmit data, e.g., `echo "hello" | ./dumbpipe connect `. DumbPipe finds a way to connect regardless of machine location, enabling easy data transfer.

ByteDance's Trae IDE: A Performance Hog with a Privacy Problem

2025-07-27
ByteDance's Trae IDE: A Performance Hog with a Privacy Problem

A recent performance and privacy analysis of ByteDance's Trae IDE, a Visual Studio Code fork, revealed alarming results. Trae consumes excessive resources, running 3.7 times more processes and using 6.3 times more memory than VSCode. Despite disabling telemetry settings, it persistently transmits detailed usage data to ByteDance servers, including system information, usage patterns, and unique identifiers. Furthermore, Trae's community management suppresses critical feedback regarding privacy and security concerns. Users should exercise caution when using Trae IDE due to its significant performance and privacy issues.

Development

Base58 vs. Base85 Encoding: A Tale of Two Encodings

2025-07-27

Base58 and Base85 encodings represent binary data in human-readable formats. Base58, using a smaller character set, is more conservative; Base85, with a larger set, is more efficient. A key difference lies in how 'base' is defined. Base58 is crucial to Bitcoin, part of the Base58Check protocol for addresses and keys. Base85 offers a more compact alternative to Base64, found in PDFs and Git patch encoding. It works by breaking bits into 32-bit words, encoding each in base 85. Variations in Base85 alphabets lead to different outputs. Base85 boasts superior efficiency, using fewer symbols and offering better computational performance.

Development Encoding

StackSafe: Conquering Stack Overflow in Recursive Rust

2025-07-27
StackSafe: Conquering Stack Overflow in Recursive Rust

Recursive functions in Rust are prone to stack overflows, crashing your program. StackSafe solves this by automatically growing the stack in recursive functions and data structures. Simply add the `#[stacksafe]` attribute, and your code works without crashes. Used in production by ScopeDB for petabyte-scale data, StackSafe provides complete protection for both recursive functions and their derived traits (like `Debug`, `Clone`, `Drop`), offering comprehensive stack safety and debug-time checks to catch potential overflows early.

Development stack overflow

BlueOS: A Lightweight, Secure, and General-Purpose Rust Kernel

2025-07-27
BlueOS: A Lightweight, Secure, and General-Purpose Rust Kernel

BlueOS is a lightweight, secure, and general-purpose operating system kernel written in Rust. It's POSIX-compliant, supports the Rust standard library, and currently supports ARM32, ARM64, RISCV32, and RISCV64 architectures with QEMU emulation. Hardware board support is under development. The project includes the core kernel, a custom libc implementation, example applications, and comprehensive documentation, providing a complete environment for developers.

Development

The Optimization Challenges of Low-Level Languages and the Future of Polyglot Programming

2025-07-27

A recurring problem in modern “low-level” languages is the difficulty in optimization due to their disconnect from hardware. The author uses Haskell and Futhark as examples, highlighting the advantages of functional languages in optimization. Their restrictive design and referential transparency allow compilers more freedom to optimize. However, some scenarios still require low-level operations, such as Rust's `unsafe` blocks. The article ultimately advocates for a polyglot programming paradigm, building meta-languages to let developers easily choose the right tool for the job, such as inline Futhark or Datalog, ultimately improving overall performance and addressing optimization challenges.

Development

Debugging Bash Scripts: Gracefully Handling `set -e` Errors

2025-07-27

This article presents a neat trick for gracefully handling errors triggered by `set -e` in Bash scripts. By using `trap 'echo "Exit status $? at line $LINENO from: $BASH_COMMAND"' ERR`, you can print information like the error line number, failing command, and exit status when the script encounters an error, making debugging easier. This leverages Bash-specific features: `$LINENO`, `$BASH_COMMAND` environment variables, and the `ERR` trap condition. Other shells like sh may behave differently and might not fully support this functionality.

Development script debugging

Implementing Dynamic Scoping in Fennel: A Clever Approach

2025-07-27
Implementing Dynamic Scoping in Fennel: A Clever Approach

The author tackles the challenge of implementing dynamic scoping in Fennel, a Lua dialect where it's not natively supported. The article explores several approaches, including manipulating function environments using Lua's debug library and cleverly cloning functions to set their environments. While the author ultimately decides against integrating this feature into the fennel-cljlib library for now, the in-depth exploration of Lua function environments and dynamic scoping, along with the comparison of different implementation strategies, provides valuable insights into functional and metaprogramming concepts.

Development Dynamic Scoping

arXivLabs: Building New arXiv Features with Community Collaboration

2025-07-27
arXivLabs: Building New arXiv Features with Community Collaboration

arXivLabs is a framework enabling developers to build and share new arXiv features directly on the arXiv website. Participants must embrace arXiv's values of openness, community, excellence, and user data privacy. Have an idea to enhance the arXiv community? Learn more about arXivLabs.

Development

Asyncio's Pitfalls: Traps in Python Asynchronous Programming and Trio's Redemption

2025-07-27
Asyncio's Pitfalls: Traps in Python Asynchronous Programming and Trio's Redemption

Python's asyncio library, while introducing the possibility of asynchronous programming, is riddled with design flaws. These include easily overlooked cancellation mechanisms, tasks being unexpectedly destroyed, traps in I/O operations, and a difficult-to-use queue. The article details these problems and contrasts them with Trio's elegant solutions. Trio addresses many of asyncio's headaches with level-triggered cancellation, strong task references, a more intuitive I/O API, and efficient channels. It provides a more reliable and user-friendly option for Python asynchronous programming. AnyIO offers a compromise, implementing Trio-like semantics on top of asyncio, balancing compatibility and ease of use.

Development

Janet: A Lightweight and High-Performance Systems Scripting Language

2025-07-27
Janet: A Lightweight and High-Performance Systems Scripting Language

Janet is a lightweight systems scripting language written mostly in standard C99, running on Windows, Linux, and macOS. It boasts minimal setup, built-in support for threads, networking, and an event loop, and features first-class closures, garbage collection, and green threads. Furthermore, Janet supports macros, tail-call optimization, and direct interoperability with C, along with a REPL and interactive debugger. A rich core library of functions and macros, coupled with the jpm build tool, makes development efficient and convenient.

Development embedded language

tinyio: A Minimalist Event Loop for Python

2025-07-27
tinyio: A Minimalist Event Loop for Python

Tired of asyncio's complex error handling? tinyio is a dead-simple (~200 lines) event loop for Python, designed for ease of use and robust error handling. It uses `yield` instead of `await`, providing a straightforward API. Upon an error in any coroutine, tinyio cancels all coroutines and provides detailed tracebacks for easy debugging. It supports nested loops and thread operations, making it ideal for simple tasks, especially when straightforward error semantics are desired.

Development

It Takes 10 Years to Become a Programming Expert: Forget Those Crash Courses

2025-07-27

This article debunks the myth of quick programming tutorials promising expertise in hours or days. The author argues that true programming mastery requires at least ten years and 10,000 hours of deliberate practice, mirroring learning curves in other fields. Examples like Mozart and the Beatles illustrate that even prodigies need years of dedicated work. The author advises aspiring programmers to choose suitable languages, prioritize hands-on experience, collaborate with others, and delve into diverse languages and low-level computer knowledge. Ultimately, consistent effort and deliberate practice, not shortcuts, are key to programming excellence.

Development
1 2 34 35 36 38 40 41 42 214 215