Tag
A blog post exploring union types and their special case, option types (T|Nothing), and the author's experiments implementing them in Copper, a minimalist low-level 'better C' language, including design restrictions and why full union types proved too complex.
博客文章论证 Pratt 解析应被视为黑盒来使用，强调理解 nuds/leds 心智模型比记忆 9 行算法实现更重要，并对比了与 GNU Bison 等传统解析技术的差异。
In his Zig talk at Code Maven, Sawyer X uses examples of configuration parsing and memory allocation to explain Zig’s core design philosophy: everything is visible, there is no hidden control flow, there are no macros or operator overloading, and problems should be turned into compile-time errors whenever possible.
A survey paper examining forty years of just-in-time compilation research from 1960 to 2000, covering the motivation, design constraints, and a classification scheme for JIT systems.
Martin Uecker 发布博客系列第一部分，深入解析 C 语言的 effective type（有效类型）规则如何支撑基于类型的别名分析（TBAA），并说明编译器如何利用这些规则进行 UB 相关优化。
作者回顾四个月重返 Zig 的经历，包括开发 snurl、参加 Zig Day Seattle（Andrew Kelley 出席）以及对 anyzig、内建 fuzzing、TLS 等的喜爱与不满，并与 Rust 做了对比。
Syl is a new systems programming language that encodes compile-time computation in a modal type system, using static/dynamic and erased/unerased mode axes to enable monomorphization and compile-time dependent types, inspired by two-level type theory and OxCaml.
C++26 failed its ISO DIS ballot—the first C++ draft ever to do so—with contracts, reflection, std::execution, and library hardening left unapproved, garnering 12 of 20 favorable votes and 9 negative votes.
A personal blog post explaining Pratt parsing by walking through the shunting yard algorithm, a simple C implementation, and the author's notes from reading Pratt's original paper while building a C expression parser that may grow into a compiler.
A technical deep-dive blog post on how dynamically typed language runtimes replace hash-table-based attribute storage with object shapes/maps (hidden classes) to speed up attribute reads and writes, building toward a small, comprehensible implementation inspired by CF Bolz-Tereick's 'A Simple Object Model'.
A blog post walking through the paper 'Flow Typing: A New Lens on Linearity', which uses the theory of lenses to solve the threading problem in linear type systems without complicating the core language, plus the author's implementation experiments in a new language called Laminar.
A blog essay arguing that Concurrent ML's event-based concurrency model improves on Go's CSP approach, unifying choice and cancellation while enabling composition and avoiding goroutine leaks, demonstrated through Racket examples.
Ante 语言设计者介绍了一种新的借用检查方案，通过融合 group borrowing 等思想，在保持无悬垂指针安全的前提下，实现零成本的循环可变性与更宽松的共享可变性检查。
Programming Language Foundations in Agda (PLFA) 是一本使用证明助手 Agda 讲解编程语言理论的开源教材，涵盖逻辑基础、操作语义与指称语义，并列出了多门采用该书授课的高校课程。
A Lobste.rs discussion of composite objects and the proposed std::polymorphic type coming in the C++26 standard, exploring how it enables type-erased polymorphism without inheritance.
一篇关于 C++ 内存安全问题的博客文章，探讨 NSA 和欧盟对内存不安全语言的警告，并在纪念 Rainer Grimm 逝世、由社区专家接手维护其博客的背景下展开讨论。
A blog post examining Java sealed classes and exhaustive pattern matching, highlighting that adding new subtypes can break consumer code and that stale compilation leads to runtime MatchException instead of compile-time errors. The author concludes sealed types are best used within component internals rather than public APIs.
A deep technical blog post introducing a novel reverse-walking borrow checker for the Valen programming language, which traverses functions backward through time to verify memory safety while optionally relaxing shared-xor-mutable rules.
Basis researchers used LLMs to write formal semantics for a small programming language and proved in Lean that the interpreter conforms to those rules after compilation to RISC-V, treating the existing interpreter as ground truth to overcome the specification bottleneck in verified software.
In his talk "Getting Canceled" at Software you can Love 2026 Vancouver, Zig Software Foundation president Andrew Kelly explains the nature of threads and concurrency from a hardware perspective (interrupts, pipelining, cache coherence), and why the fundamental complexity introduced by contention cannot be eliminated by software abstractions.