Category: Development

Multi-Stage Programming with Splice Variables: Safe and Predictable Code Generation

2025-06-28

This paper introduces a novel technique called Multi-Stage Programming (MSP) that allows programs to generate other programs. To ensure safe and predictable code generation, the authors introduce the concept of "splice variables." Splice variables provide fine-grained control over the code generation process and seamlessly scale to advanced features like code pattern matching and rewriting. The type system automatically tracks variable dependencies, ensuring that the generated code is always well-formed, properly scoped, and type-checks correctly. The paper demonstrates the power of splice variables with examples such as generating a power function and showcases features like code pattern matching and rewriting.

arXivLabs: Experimental Projects with Community Collaborators

2025-06-28
arXivLabs: Experimental Projects with Community Collaborators

arXivLabs is a framework enabling collaborators to develop and share new arXiv features directly on our website. Individuals and organizations working with arXivLabs embrace our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only partners with those who adhere to them. Have an idea for a project that will benefit arXiv's community? Learn more about arXivLabs.

Development

A Concise Rust Kernel Driver: The AX88796B Ethernet Controller Example

2025-06-28

This article details the experience of writing a Linux kernel driver for the AX88796B embedded Ethernet controller using Rust. The author contrasts the Rust version with its C counterpart, highlighting differences in syntax, types, and APIs. The Rust version is remarkably concise, at just over 100 lines, leveraging macros to simplify driver registration and using traits and the `#[vtable]` macro for seamless integration with existing C code. The article clearly explains the advantages of Rust in kernel driver development, such as memory safety guarantees through references and simplified error handling using `Result` and the `try` operator, providing valuable insights for Rust kernel driver development.

Development Kernel Driver

bootc-image-builder: Craft Bootable Disk Images from Containers

2025-06-28
bootc-image-builder: Craft Bootable Disk Images from Containers

bootc-image-builder is a powerful tool for creating disk images from Fedora/CentOS bootc containers or derivatives. It supports various image types (qcow2, AMI, ISO, etc.) and allows customization of users, filesystems, kernel parameters, and more. Using Podman and QEMU, users can easily build and run virtual machines. This guide details its usage, options, and advanced configurations such as creating AMIs on AWS and customizing the Anaconda installer.

Development disk image

Rust's Weird Expressions: Pushing the Type System to its Limits

2025-06-28
Rust's Weird Expressions: Pushing the Type System to its Limits

This article delves into some extreme and seemingly paradoxical expressions within Rust's powerful type system. By dissecting examples from the `weird-expr.rs` test file, such as the creative use of `return true`, nested loops and `break` statements, and a deep understanding of type inference and coercion, the article explains their validity in Rust. These are not bugs, but rather showcases of Rust's flexible type system and expressive power, demonstrating its robustness in handling edge cases.

Development

The 14-Year-Old Who Shaped the Mac Calculator

2025-06-28

Chris Espinosa, a 14-year-old Apple employee, played a pivotal role in the Macintosh's development. Tasked with documenting Quickdraw, he built a calculator program. Steve Jobs initially disliked it, but Espinosa's innovative solution—a customizable 'Steve Jobs Roll Your Own Calculator Construction Set'—impressed Jobs and became the iconic Mac calculator for years, lasting until OS 9.

Development

SymbolicAI: A Neuro-Symbolic Framework for LLMs

2025-06-28
SymbolicAI: A Neuro-Symbolic Framework for LLMs

SymbolicAI is a neuro-symbolic framework blending classic Python programming with the differentiable programmability of LLMs. Its modular design allows easy extension and customization, enabling users to write their own engines, host them locally, or interface with tools like web search and image generation. Core concepts are Symbol objects (syntactic and semantic) and contracts (ensuring code correctness via decorators). SymbolicAI supports numerous primitive operations and integrates with neuro-symbolic engines like OpenAI and Anthropic via APIs, along with tools such as Wolfram Alpha and search engines. A priority-based configuration system simplifies management.

Development neuro-symbolic

c4wa: A Minimalist and Efficient C to WebAssembly Compiler

2025-06-28
c4wa: A Minimalist and Efficient C to WebAssembly Compiler

c4wa is a compiler that translates a subset of C into WebAssembly. Unlike other compilers, it generates minimalistic and well-optimized WebAssembly code without any glue, embedded libraries, or overhead. It's fully compatible with any WASM runtime out of the box. c4wa supports loops, conditionals, structs, arrays, pointers, and other typical C features, and can output readable WAT format code. It strikes a balance between the higher-level convenience of C and the low-level efficiency of WebAssembly, offering developers a new way to write performant WebAssembly code.

Development

ZubanLS: A Blazing-Fast Python Language Server Built in Rust

2025-06-27

In 2012, the author created Jedi, a widely used Python autocompletion library. However, its speed limitations became apparent. In 2020, the author rebuilt from scratch using Rust, resulting in ZubanLS, the first truly fast Python language server after five years of dedicated work. ZubanLS targets professionals needing precision, reliability, and speed, addressing longstanding issues in tools like Mypy and Pyright by prioritizing performance without sacrificing features. Support for Django, go-to-definition, completions, and other LSP features is in progress. The initial 2025 release might not be perfect; feedback is welcome to shape future development.

Development

A Lisp Adventure in the Dead Waters of C

2025-06-27

This article explores the power of Lisp's abstractions and the limitations of C, using a C-like language. The author analyzes function parameter evaluation strategies, highlighting how C's pass-by-value mechanism restricts control over function parameters, preventing the implementation of flexible conditional statements and loops like Lisp's if, while, and cond. The article further delves into advanced features like closures and runtime function creation, unavailable in C, ultimately concluding on C's shortcomings in extensibility.

Development

Linux Community: Fortress of Freedom or Cage of Exclusion?

2025-06-27

A blog post sparked a heated debate about inclusivity within the Linux community. The author shared a condescending and exclusionary comment criticizing their use of "Linux" instead of "GNU/Linux" and accusing them of trying to "dumb down" the system. The author counters that true "freedom" shouldn't come at the expense of marginalized groups, highlighting serious accessibility flaws in the Linux ecosystem. This ignited a discussion about community culture, the importance of inclusivity and accessibility, and respect for those who contribute to improving the system.

Development

zenta: Terminal-Based Mindfulness for Coders

2025-06-27
zenta: Terminal-Based Mindfulness for Coders

zenta is a terminal-native tool designed to help programmers maintain focus while coding. It guides users back to the present moment through simple breathing exercises, without the need for tracking or metrics. A single command, `breath` or `breathe`, initiates short or longer breathing sessions, aided by pure visual animations and calming quotes. The `reflect` command facilitates a gentle daily review. zenta advocates for genuine mindfulness, not gamification, emphasizing presence over productivity hacks. It supports multiple operating systems and is open-sourced under the MIT license.

Development

BQN Matrix Multiplication Performance Optimization: Cache Blocking and Divide and Conquer

2025-06-27

This article explores optimizing large matrix multiplication performance using the BQN language. The author first uses a simple square partitioning method to effectively utilize cache, achieving a speedup of about six times. Then, a Strassen algorithm based on a divide-and-conquer strategy is introduced and experimentally shown to achieve up to a 9x speedup on large matrices. The article also compares the performance impact of different block sizes and nested tiling strategies, concluding that the performance limit of a pure, single-threaded BQN implementation has essentially been reached.

Development

Blazing Fast Fibonacci on the GPU with Thrust

2025-06-27
Blazing Fast Fibonacci on the GPU with Thrust

This blog post demonstrates how to perform incredibly fast Fibonacci sequence calculations using GPU programming and the NVIDIA Thrust library. It starts by explaining the scan algorithm, then shows how to use scan operations in Thrust for simple addition and multiplication, extending this to matrix operations. Finally, it illustrates calculating Fibonacci numbers efficiently via matrix operations and the scan operation, using modulo arithmetic to avoid integer overflow. The author calculates F99999999 (mod 9837) in just 17 milliseconds on an NVIDIA GeForce RTX 3060 Mobile GPU.

Cache Locality and Array Summation Performance: A Surprising Experiment

2025-06-27

This article explores the impact of array element order on summation performance through experimentation. The author compares sequential and random access methods, finding that random access performance drastically degrades when array size exceeds cache capacity, while sequential access remains relatively stable. Experiments also investigate memory-mapped files and cross-platform differences, revealing that OS handling of memory-mapped files significantly impacts performance. The conclusion: sequential access is optimal for large array summation, while larger-than-memory data requires more efficient algorithms and data reading strategies.

Development cache locality

From Flutter & Rust to Pure Rust: A Case Study in Simplifying AI App Development

2025-06-27

The developer of a small AI application, BoquilaHUB, shares their experience transitioning from a Flutter/Rust architecture to a pure Rust application using egui. Initially using flutter_rust_bridge to connect a Flutter UI with a Rust backend, the developer encountered frustration with code generation overhead, FFI complexities, and the challenges of designing a cross-language API. Switching to egui, a Rust-based GUI library, and rewriting the UI over a weekend proved transformative. The pure Rust approach simplified project complexity, improved code readability and maintainability, and yielded significant performance gains. The developer highlights egui's ease of use in eliminating common Flutter UI refresh issues and complex state management, resulting in a faster and more responsive application.

Development

SigNoz: Open Source Application Monitoring Dev Advocate Wanted

2025-06-27
SigNoz: Open Source Application Monitoring Dev Advocate Wanted

SigNoz, a global open-source application monitoring project with 21,000+ GitHub stars and 6,000+ Slack community members, is hiring a Developer Advocate. This role involves engaging with the community, creating dev-focused blogs and videos, presenting SigNoz at meetups and conferences, and assisting users with setup and use cases. You'll work on a global dev infra product, engage with the open-source community, and be backed by YC and prominent US VCs. Requires 1+ years of software engineering experience, familiarity with various programming languages and deployment methods (e.g., k8s, Docker), active participation in developer communities, and knowledge of cloud-native ecosystems, Kubernetes, and OpenTelemetry is a plus.

Development developer advocate

Blender 5.0 Linux Gets Experimental HDR Support (Wayland/Vulkan)

2025-06-27

Blender 5.0's upcoming Linux release will experimentally support High Dynamic Range (HDR) displays, but only when using Wayland and Vulkan. This means you'll need an HDR monitor, a Wayland desktop environment, and Vulkan acceleration to use it. The feature is currently under testing and its inclusion in the final release is not guaranteed.

Development

Swift Takes on Android: Apple's Language Crosses the Platform Divide

2025-06-27
Swift Takes on Android: Apple's Language Crosses the Platform Divide

Apple's Swift programming language is expanding into Android app development. While Android primarily uses Kotlin, a newly formed Swift Android Working Group aims to make Android an officially supported platform. This group's goals include improving Android support for Swift, optimizing core Swift packages for Android's idioms, defining supported API levels and architectures, and establishing best practices for bridging Swift with Android's Java SDK. Although third-party tools already enabled Swift for Android development, Apple's move signifies a strategic expansion in mobile development.

Development

AI-Powered Dataset Generator: Instantly Preview, Export, and Explore Data

2025-06-27
AI-Powered Dataset Generator: Instantly Preview, Export, and Explore Data

This tool leverages AI (GPT-4) and Faker to generate realistic datasets for demos, learning, and dashboards. Customize datasets via a conversational prompt builder, preview data in real-time, and export as CSV or SQL. It integrates with Metabase for easy data exploration. OpenAI API calls (costing ~$0.05) are only made for data previews; CSV/SQL downloads are free, generating more rows based on the preview's schema. Supports both One Big Table (OBT) and Star Schema for flexible analytics.

Development dataset generation

uv and Ray: Revolutionizing Dependency Management for Distributed Python

2025-06-27
uv and Ray: Revolutionizing Dependency Management for Distributed Python

This article showcases the integration of the uv package manager with the Ray compute engine, addressing the challenges of dependency management in distributed Python applications. Traditional containerization methods slow down iteration speeds. The uv + Ray combination allows for rapid creation and synchronization of consistent Python environments across a cluster, dramatically improving development efficiency. By setting the environment variable `RAY_RUNTIME_ENV_HOOK`, Ray automatically detects the uv environment and applies it to all worker processes, ensuring consistent code execution. The article demonstrates its ease of use with examples using Ray Data and LLM integration, and covers advanced usage and best practices.

Development

typr: A TUI Typing Test with Smart Word Selection

2025-06-27
typr: A TUI Typing Test with Smart Word Selection

typr is a command-line typing test tool inspired by Keybr's word selection algorithm. It optimizes your typing speed by weighting accuracy, letter frequency, and typing speed. Featuring a cool curses-based TUI, it saves your data in a JSON file. Customize your test with options for time limits, word counts, or even endless practice.

Development typing test

Proposal: Add a Declarative Templating API to the Web Platform

2025-06-27
Proposal: Add a Declarative Templating API to the Web Platform

This proposal suggests adding a declarative templating API to the web platform. The author argues that while the existing DOM API is powerful, it lacks ergonomic templating capabilities, forcing developers to rely on various frameworks and libraries, increasing development overhead and application size. Declarative templating offers superior code readability, security, performance, and maintainability, aligning with modern web development trends. The proposal suggests leveraging existing Tagged Template Literals, incrementally implementing the API, ultimately supporting HTML templates, thereby enhancing the web development experience.

Local Network File Syncing for Two Windows Machines: Ditch the Cloud!

2025-06-27
Local Network File Syncing for Two Windows Machines: Ditch the Cloud!

Tired of syncing files between two Windows machines? Sink offers a revolutionary solution! Bypass the cloud, email, and USB drives. Running on your local network, Sink automatically detects other machines running Sink and syncs files near-instantly. It handles conflicts, preventing data loss, and allows you to ignore specific files and folders using a .sinkignore file (similar to .gitignore). Currently a work in progress, future plans include a UI, custom paths, system tray integration, and support for more than two devices.

XSLT: A Zero-Config Static Site Generator Built into Your Browser

2025-06-27
XSLT: A Zero-Config Static Site Generator Built into Your Browser

Tired of complex build systems like Next.js, the author sought a simpler way to build static websites. After exploring various options, they discovered XSLT, a language for transforming XML into HTML. By storing website data as XML and using XSLT for transformation, they created a 'client-side' build system requiring no extra tools. The browser handles the XSLT transformation directly, generating the final HTML—a zero-config solution for static site generation. While not a perfect replacement for all scenarios, it offers developers a powerful alternative.

Development zero-config

Kea 3.0 Released: More Open, Longer-Term Support

2025-06-27
Kea 3.0 Released: More Open, Longer-Term Support

ISC is thrilled to announce the release of Kea 3.0.0, the first Long-Term Support (LTS) version! This major release opensources twelve previously commercially licensed Kea hooks, enhancing security and simplifying the installation process and client classification. Kea 3.0 also features a modernized Meson build system and native API access via HTTP and TLS, eliminating the need for the Kea Control Agent. This release marks a significant step towards a more open and maintainable Kea.

Development

My Rust Build Time Went From 4 Minutes to 32 Seconds

2025-06-26

The author's Rust website took 4 minutes to build, requiring a rebuild, copy, and restart for every change. To speed things up, Docker containers and cargo-chef were used for dependency pre-building, but with limited success. Using rustc's self-profiling and LLVM trace data, the author identified link-time optimization (LTO) and LLVM module code generation as major bottlenecks. Through a series of optimizations, including adjusting LTO levels, optimization levels, and breaking up large async functions, build time was reduced from 4 minutes to 32.3 seconds.

Matrix 1.15 Released: Next-Gen Authentication & Improved Room Summaries

2025-06-26
Matrix 1.15 Released: Next-Gen Authentication & Improved Room Summaries

Matrix 1.15 is here, boasting improvements to authentication, room summaries, and rich topics! This release incorporates 10 MSCs, highlighting the implementation of a next-generation authentication system – a significant step towards Matrix 2.0. New features also include enhanced room summaries, providing clients with richer room information, and support for rich text in room topics. These improvements enhance Matrix's security, user experience, and functionality.

Development Room Summaries

Minimalist RSS Reader: Building a Personalized Blog Feed with Deno

2025-06-26

Tired of bloated RSS readers? The author took a different approach, building a custom RSS reader using Deno and a simple text file. It displays only the titles and links of the three latest posts, without local full-text storage or read/unread markers, and is automatically updated daily via GitHub Actions. The code is concise, easy to understand and extend, a minimalist's dream.

Development

From Noise to Precision: AI Code Review, Reimagined

2025-06-26
From Noise to Precision:  AI Code Review, Reimagined

Cubic's AI code review agent, initially plagued by excessive noise and false positives, underwent a significant transformation. Three key architectural revisions led to a 51% reduction in false positives. These improvements included requiring explicit reasoning from the AI before feedback, streamlining the toolset to essential components, and employing specialized micro-agents for focused tasks. The result? A smoother, more efficient code review process with increased developer trust and productivity.

Development
1 2 39 40 41 43 45 46 47 202 203