Tag
An exploration of multistack concatenative programming languages, discussing how auxiliary stacks and dynamic bindings like Factor's namespaces and PostScript's dictionaries can ease data stack management without sacrificing concatenative composition.
This technical note from 1994 describes methods for constructing deterministic and nondeterministic finite state automata in Forth, emphasizing a one-to-one mapping between definitions and state tables to avoid slow nested IFs.
The author argues that despite the common call to break ABI to save C++, preserving a stable ABI is necessary to allow C to evolve, and discusses the trade-offs and constraints ABI stability imposes on language and standard library improvements.
The author discusses a talk given at a Python meetup about projects they would no longer use Python for in 2026, outlining its limitations and alternatives while acknowledging Python still shines in certain areas.
A tutorial on using PLT Redex to model ISWIM, the first part of a series on modelling actor-like systems.
Interview with Lua creator Roberto Ierusalimschy covering Lua's unique embedding-oriented design, its differences from Python, LuaJIT's workings, and predictions for AI's impact on programming languages.
The article discusses the recent proposal for memory safety in Zig via Fil-C, compares Fil-C's definition of memory safety with Rust's, and argues that memory safety is a spectrum with practical definitions, using a concrete example where Fil-C is still unsafe.
C++26 introduces changes to reduce undefined behavior, notably making it ill-formed to delete a pointer to an incomplete type, improving program safety.
By treating types as positive spaces for constructing new values rather than negative spaces for restricting values, and combining product types and sum types, we can precisely model data invariants and avoid fighting with the type checker. It recommends using simple type composition rather than complex type system features.
The article explores the inherent trade-offs between concurrency, interactivity, and mutability in programming languages, using examples from Common Lisp, Python, Ruby, and Erlang to illustrate that no language can fully optimize all three.
This chapter from 'Let Over Lambda' explores implementing the Forth programming language in Lisp using macros, emphasizing duality of syntax and meta-programming techniques. It aims to teach Forth concepts to a Lisp audience and discuss the philosophy behind Forth's design.
The article critiques memory safety absolutism in programming language debates, arguing that new approaches like Fil-C have trade-offs and that dismissing Rust as unsafe ignores practical benefits.
HOPL is an online historical encyclopaedia cataloging 8,945 programming languages from the 18th century to present, with influence links and citations, though currently showing an internal database error.
A reflective essay arguing that programming languages are authoring tools for platforms, using historical examples like IBM and Microsoft to illustrate how languages shape ecosystems and developer communities.
In the age of AI-assisted coding, the author argues that deep understanding of programming language concepts remains essential for engineering, listing key ideas from various languages that expand mental models for problem solving.
This blog post details the evolution and recent refactoring of Futhark's type checker, from a simple type checker to Hindley-Milner inference and the complexities of adding features like uniqueness types and size types.
Discusses two approaches to parallelizing compilation: multi-process (single-threaded compiler with build system spawning multiple instances) and in-process multi-threading (used by Rust and Zig). Compares trade-offs for language design.
An email exchange about the CoSy language and its creator's critique of Git as overly complex for personal productivity, contrasted with the simplicity of CoSy's directory-based approach.
This article examines explicit capture clauses in Rust as an alternative to move expressions, proposing a first-class language feature for converting references to owned values and analyzing various closure capture patterns.
A blog post discussing the design of integer types in various programming languages, arguing that Rust's approach of forcing explicit sizing and signedness selection is superior to languages with a default `int` type.