Programming Languages news and developer summaries

Bjarne Stroustrup addresses common C++ questions, emphasizing modern practices like RAII, standard containers, and abstract classes. He advocates for type safety, avoiding C-style casts and manual memory management, and highlights the importance of consistent coding standards over specific syntactic preferences. The text underscores that C++ provides powerful tools to manage complexity, improve performance, and ensure reliability.

The Bun project is undergoing a massive rewrite from C++ to Rust, achieving 99.8% test suite compatibility on Linux. This 960,000 LOC migration aims to improve memory safety, stability, and maintainability by leveraging Rust’s borrow checker and destructors, effectively reducing manual debugging for crashes and memory leaks.

Writing bug-free C and C++ is nearly impossible due to the prevalence of undefined behavior (UB). UB is not just about compiler optimizations; it fundamentally means the compiler assumes code validity, leading to unpredictable hardware results. Even experienced developers cannot avoid these subtle traps, making AI an essential tool for detecting and mitigating UB in modern codebases.

Python 3.15 introduces several key features, including a simplified TaskGroup cancellation in asyncio, enhanced ContextDecorator support for async and generator functions, and new threading utilities for managing thread-safe iterators. Additionally, updates include XOR operations for collections.Counter and immutable JSON parsing via frozendict.

Async Rust struggles with binary bloat, especially on embedded systems, due to complex state machine generation. Proposed optimizations include removing panic states in futures, omitting state machines for functions without await points, future inlining, and collapsing duplicate states. Implementing these in the compiler could significantly reduce binary size and improve performance across various architectures.

The Rust code encounters Undefined Behavior due to the creation of a dangling reference when using core::slice::from_raw_parts on a memory location after the owning Box has been dropped. This highlight the necessity of strict adherence to Rust's memory safety rules regarding ownership and pointer provenance when performing unsafe operations.

cuda-oxide is an experimental Rust-to-CUDA compiler enabling developers to write high-performance GPU kernels directly in idiomatic Rust. By utilizing a custom rustc codegen backend, it compiles to PTX without proprietary DSLs or foreign bindings, leveraging Rust's ownership and safety models for GPU programming while supporting async workflows.

Mojo is a modern, AI-native programming language designed to combine Python's syntax with C++-level performance. It features memory safety, CPU and GPU flexibility without vendor lock-in, and seamless Python interoperability. The project aims to bridge the gap between high-level ease of use and low-level hardware optimization, with plans for full open-source availability by 2026.

A hobbyist documents the design of a stylish voltmeter clock using analog panel meters and a custom wooden enclosure. Created with an AVR128DB28 MCU, the project uses high-frequency digital pulse control instead of DACs to drive the meters. The build process highlights CNC milling and bent wood techniques for a polished, aesthetic finish.

The Zig development log for 2026 highlights significant updates, including a reworked build system for faster performance, LLVM backend incremental compilation, and a redesigned type resolution system. Key additions include experimental evented I/O implementations, improved package management with local caching, and a strategic migration to native Windows APIs, alongside ongoing efforts to replace vendored libc with Zig-native implementations.

The author explores using Prolog to manage complex Pokémon battle mechanics, finding it superior to SQL and spreadsheets for querying intricate rules. By defining predicates and rules, the author demonstrates how logic programming efficiently models relationships and game logic, offering a flexible and readable approach for building advanced battle analysis tools.

The C++ standard library has struggled for 15 years with design flaws it cannot easily fix due to strict ABI compatibility requirements. As a result, the library has become a collection of suboptimal defaults—like legacy containers and wrappers—widely discouraged in modern codebases, forcing professional engineers to rely on third-party libraries instead of standard solutions.

Developers are exploring running Haiku OS on Apple Silicon using m1n1 and u-boot. While bare-metal booting to the desktop on M1 hardware is achievable, the system lacks native ARM64 development packages and faces driver limitations like sluggish USB performance. Options for setting up build environments include cross-compilation and manual package porting via FAT32 disk images.

The ClojureScript team announced a new release enabling native async/await support for JavaScript interoperability. By using the ^:async hint, developers can compile functions into native JavaScript async functions. This update simplifies interaction with modern Browser APIs and popular libraries, directly addressing a top priority requested by the Clojure community.

Linux users widely favor the vi text editor family due to its efficiency and near-universal availability. This guide explores the history and evolution of vi, detailing various clones and modern derivatives like Vim and Neovim, while clarifying their differences in features, lineage, and support for features like UTF-8, scripting, and large file editing.

let-go is a fast, lightweight Clojure-dialect implemented in Go, featuring a 10MB binary and 7ms cold start. It supports AOT compilation to standalone binaries, WASM web apps with terminal emulation, and provides seamless Go interop. It aims to offer idiomatic clojure development without being a drop-in replacement, including core.async, pods, and nREPL compatibility.

Presented at the 2026 Outline Demoparty, this 16-byte x86 assembly routine performs algorithmic art in DOS. By XORing video memory to generate a Sierpinski fractal, the code simultaneously renders visual patterns and produces audio via the PC speaker. The project demonstrates extreme memory efficiency and the interplay between mathematical sequences, display hardware, and low-level system design.

The author successfully jailbroke a 7th gen Kindle Paperwhite and implemented a Rust-based UI using the Slint framework. By cross-compiling for ARMv7 using cargo-zigbuild, and bridging Slint to the Kindle's framebuffer and touch driver via memory-mapped files and ioctl, they developed a custom backend, enabling interactive applications on the e-ink device.

Erlang/OTP 29.0 is a major release introducing native records, multi-valued comprehensions, and improved security defaults for SSH. It adds unsafe function warnings, updates SSL with post-quantum algorithms, and includes new testing and terminal styling modules. Several language improvements, compiler optimizations, and deprecated construct warnings prepare the ecosystem for future versions.

This roguelike game features a unique magic system based on a Lisp dialect called let-go. Players explore dungeons using s-expressions while managing an inverted power curve. The game, inspired by Brogue, is built on a custom Go bytecode VM with no dependencies, supporting native and WASM execution.