Tag
Martin Odersky, creator of Scala, argues that types will become the contract between humans and AI-generated code, helping humans maintain control as AI writes and exploits vulnerabilities in code at scale.
This paper introduces a theory of bidirectional type slicing, where selecting a term and querying its type information yields a minimal program slice sufficient to explain that type. The metatheory is mechanised in Agda and a linear-time approximation is implemented for the Hazel programming environment.
RacketCon 2026, the sixteenth gathering for the Racket programming language community, is happening Saturday with a live stream and talks on notation, type inference in Typed Racket, and low-level language-oriented programming via the new Pille language.
A technical writeup presenting lang_narrow, a small language with flow typing that structurally narrows union types at control-flow branches using is/in expressions, along with a runtime implementation, performance considerations, and discussion comparing its union types to algebraic data types.
This article explores how promising technological ideas sometimes fail initially but are later realized with improved tooling, exemplified by historical and modern projects in programming and scientific computing.
The article discusses the challenges of unsizing unsized values in Rust compared to Go's dynamic typing with interfaces, highlighting limitations in Rust's type system for handling non-sized types.
This article lists upcoming sessions at the World Congress 2026 North America conference, focusing on topics such as type systems, AI-driven coding, and software engineering practices.
This article discusses three programming language features: flow typing for dynamic feel in static languages like Crystal and TypeScript, borrow checking for memory safety in Rust, and contract programming for invariant checking in D.
The author explains why effect systems in programming languages are exciting, offering better control over resource interactions, composability, and testability compared to current systems.
Simon Peyton Jones explains functional programming's mathematical foundations, benefits like improved maintainability, and its influence on mainstream languages, while discussing challenges such as handling side effects.
Niko Matsakis describes an alternative alias-based formulation of Rust's borrow checker, where regions are sets of loans rather than program points, with a working prototype that passes the NLL test suite.
A blog post explaining the principle of 'Unconditional Election' in Haskell, using parametric polymorphism and free theorems to enforce behavior via type signatures.
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.
A specification language that provides automated feedback when specifications are incorrect, helping developers catch errors early.
A technical blog post discussing how structural descriptions like type systems and build systems leverage graph-structured models to ensure correctness, highlighting the definitional nature of systems like Bazel.
A curated collection of counterexamples that demonstrate limitations and pitfalls in type systems, serving as an educational resource for programmers and language designers.
A formal core calculus for documents is presented, likely exploring type systems or semantics for document processing.
Argues that TypeScript is a poor default for the AI era due to its unsound type system, which fails to catch errors in AI-generated code, and likens it to Paul Graham's Blub paradox.
The author argues that the resurgence of static typing in the 2010s was due to improved type systems (e.g., TypeScript, Haskell, Rust) that offer nullable type handling, sum types, and type inference, contrasting with poor static typing in earlier languages like Java and C++98.
This article introduces a new approach to memory safety based on linear types and abstract interpretation, aiming to eliminate common bugs like use-after-free and memory leaks more ergonomically than Rust.