Topic
Everything filed under Programming Languages, newest first.
RSS · JSON · All topics
Anna Liberty reflects on four months back in Zig after Rust: projects like the smallnet library snurl, Zig Day, what she likes (anyzig, the new IO and allocator interfaces, comptime, the build system, dependency culture, error handling, incremental compilation) and what she wants improved, including stability, lifetime support, documentation and bootstrapping.
13 min · 2,942 words
Our Response To The eMudhra Key Disclosure Incident
Roland Shoemaker of the Go Security team explains why Go shipped its first-ever URGENT-track security release after weak keys on eight eMudhra intermediate certificates made it possible to forge TLS certificates, with a timeline of the roughly seven-and-a-half-hour response and how to check whether your Go binaries are affected.
6 min · 1,294 words
The Pharo team announces Pharo 14, focused on modernizing development tools (Mission Control, Pulse, new Method and Settings browsers), rebuilding refactoring and command infrastructure, and VM work including RISC-V JIT support, with a move to a fall release schedule.
3 min · 754 words
Max Slater introduces Syl, a systems language that encodes compile-time computation in a modal type system inspired by two-level type theory and OxCaml: values carry staticity and erasure modes, enabling dependent types, proofs and totality checks, with examples like a typed interpreter and length-indexed vectors and planned extensions such as modules, reflection and user-defined layouts.
11 min · 2,608 words
OpenLDK: Bringing the Java World into Common Lisp
Anthony Green, who once worked on gcj, introduces OpenLDK, a JIT compiler and runtime that translates Java bytecode into Lisp so SBCL can compile it to native code, and shows recent progress running JVM-hosted languages, Spring Boot apps and saved images alongside Common Lisp.
10 min · 2,330 words
Go 1.28 HTTP/2 Parking: Measuring Memory Savings
Mohammad Abdolirad benchmarks the HTTP/2 connection parking change in Go 1.28 with 5,000 idle connections, finding the same server binary used 85 to 93 MiB less RSS with parking enabled, with fewer goroutines and less stack memory, and discusses why HeapAlloc told a less simple story and the limits of the test.
5 min · 1,204 words
Much Ado About None: Sentinel Values in Python
Florian Wilhelm explains why None is often the wrong way to express absence in Python, how sentinel values resolve the ambiguity, and how PEP 661 made them first-class with a new sentinel built-in in Python 3.15.
2 min · 504 words
Embedding EYG in Erlang programs
Step-by-step guide to embedding EYG scripting in an Erlang application: installing the toolkit, using EYG types, effects and packages from Erlang, and type-checking scripts before running them to give users or agents a tightly controlled scripting environment.
5 min · 1,043 words
Release notes for ZLS 0.17.0, the Zig language server from zigtools: feature improvements such as not following aliases when renaming symbols, bug fixes, and download links for all supported platforms.
2 min · 524 words
John Earnest's Beyond Loom tutorial uses Hershey vector fonts to teach Lil, Decker's APL-influenced scripting language: points, strokes, and paths as nested lists, then layout and drawing primitives for 2D vector text and shapes.
8 min · 1,784 words
Objects, attributes, maps, oh my!
Max Bernstein walks through how dynamic language VMs move from hash-table objects to hidden classes (shapes or maps) and inline caches, with Python sketches and notes on how ZJIT handles polymorphic shapes in Ruby.
13 min · 3,019 words
Today's PHP Security Release, and How We're Strengthening PHP Security
The PHP Foundation explains the two critical RCE vulnerabilities fixed in PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35, how they were found with researchers and AI security tools and fixed, how PHP security handling has changed over two years, and what dependent organizations need to fund.
8 min · 1,860 words
Papers We Love: Flow Typing, A New Lens on Linearity
Jared Forsyth works through a new paper on flow typing that aims to make linear types far less cumbersome, implementing its execution model and explaining how it treats values as pass-by-value with immutable updates, and what that could mean for language design.
6 min · 1,388 words
2026 is an exciting year for the Rust compiler (and me)
Rust compiler contributor Matyáš Racek surveys long-running rustc efforts paying off in 2026, including the next-generation trait solver, Polonius, the parallel frontend nearing stabilization, LLVM and micro-optimization speedups, move elimination, polymorphization, Cargo cache and build-dir changes, and reflections on the Rust All Hands.
11 min · 2,539 words
Borrow Checking Zero-Cost Cyclic Mutability
Jake Fecher describes the new design of Ante's borrow checker, which blends group borrowing with his own ideas to relax Rust's aliasing-xor-mutation rule while still statically preventing dangling pointers, enabling safe shared mutability, cyclic mutability and complex data flow at zero runtime cost.
16 min · 3,737 words
Dynamic Packages for Free Pascal and Lazarus
The getlazarus.org maintainer announces the first release of full dynamic package support for the Free Pascal Compiler and Lazarus IDE, letting components and plugins be built as shared libraries and installed without rebuilding the IDE, and covers restrictions, runtime changes, IDE improvements and how to help.
5 min · 1,157 words
Composite objects and C++26 the std::polymorphic type
Marius Bancila explains C++26's std::polymorphic, the companion to std::indirect for owning polymorphic members in composite classes, covering value semantics, copying, and how it simplifies strategy objects, AST nodes, and similar has-a hierarchies.
8 min · 1,888 words
A New Way to Think About Borrow Checking (In Reverse)
Evan Ovadia explains how the Valen programming language's borrow checker walks functions backwards, in reverse control-flow order, so it already knows how references will be used later, walking through its static typing, static grouping and safety-checking phases, loops, and how the design compares with Rust's borrow checker.
15 min · 3,517 words
Andrea Piseri looks at how array languages like APL implement scans over packed boolean arrays, where a naive loop manages about 0.6 elements per cycle. Using truth-table symmetries, the essay shows that fast versions of just and, less-than and xor are enough to derive good implementations of every other boolean scan, with bit-twiddling implementations in an appendix.
14 min · 3,251 words
Parser CombinatorsBetter than regex!
A hands-on TypeScript introduction to parser combinators: starting from a partial parser type, chaining parsers with sequencing and mapping, and building up a hand-rolled combinator library that parses real ping output into structured data, as a cleaner middle ground between regex and tree-sitter.
7 min · 1,661 words