Tag
This paper presents a modified Rust compiler for the Morello capability hardware architecture, enabling always-on memory safety even in unsafe code by leveraging hardware capabilities.
Xavier Leroy, creator of OCaml, discusses OCaml's features compared to Rust and JavaScript, formal verification, type inference, and the impact of LLMs on programming in a podcast interview.
This article discusses a fundamental memory safety challenge involving tagged unions where a pointer to one variant is used after the union is overwritten with a different variant, leading to type confusion. The author also argues that buffer overflows are the most exploitable memory error and could have been mitigated with better array syntax.
This article from 1998 argues that ML and OCaml are excellent for writing compilers due to features like garbage collection, tail recursion optimization, and algebraic data types with pattern matching, which simplify handling complex compiler data structures.
The Roc compiler team has rewritten their 300,000-line Rust codebase into Zig, achieving feature parity after 18 months, resulting in smaller WebAssembly binaries and improved performance.
The article explores obscure details about pre-ANSI C (K&R C) including the absence of void, different floating point types, and simplified type specifier rules. It explains how the language's context-sensitive grammar was justified by single-pass compiler constraints.
The author explores the concept of null pointers, discussing their semantic role and proposing that other invalid pointer values could be used to store additional information, akin to NaN boxing.
This Wired article examines Python's performance limitations in scientific computing and discusses Julia as a potential solution to the two-language problem, drawing historical parallels from Turing Award lectures.
This article explores the importance of syntax design in programming languages, arguing that syntax should accurately reflect the language's computational model and mental model, rather than being arbitrarily cobbled together for familiarity or conciseness. The author analyzes the syntax design of OCaml, Lisp/Clojure, and JavaScript, and introduces his own language Saul, emphasizing uniformity and semantic consistency.
The article presents an argument for learning Lisp, highlighting its unique features like macros and extensibility that allow programmers to adapt the language to their problems, and discusses the Blub paradox to explain why programmers from less powerful languages may struggle to recognize Lisp's advantages.
This article explores two unexpected behaviors of NaN in Python and Lua, where implicit assumptions about equality and comparison lead to surprising results like Python's list equality ignoring NaN's self-inequality and Lua's for-loops mishandling NaN as step or limit.
An article discussing the debate between signed and unsigned integer defaults in programming language design, using Odin and C3 as examples. The author argues that signed-by-default is more practical despite theoretical advantages of unsigned.
The author describes their journey from Zig to Rust and back to Zig, exploring the trade-offs between stability and expressiveness in programming languages.
This article examines the declining popularity of Fortran in scientific computing and proposes modernizing it with dependent types to address the shortage of skilled Fortran programmers.
A quote comparing the trade-offs between C and Haskell: C prioritizes efficiency first then correctness, while Haskell prioritizes correctness then efficiency.
The article explores how AI code generation excels at local code chunks but struggles with global program understanding, leading to excessive defensive checks. It examines whether programming language design can help, using an example of local reasoning assuring global properties.
A curated collection of counterexamples that demonstrate limitations and pitfalls in type systems, serving as an educational resource for programmers and language designers.
This research proposal investigates how coding LLM perplexity scales with codebase size across different programming languages, using Lean as a test case for formal languages. It suggests that Lean may have better scaling exponents, leading to safer and more secure software at scale.
A formal core calculus for documents is presented, likely exploring type systems or semantics for document processing.
OxCaml, Jane Street's superset of OCaml, introduces a `[@zero_alloc]` annotation that forces the compiler to refuse to build if any function in the call tree allocates on the heap, shifting allocation detection from runtime profiling to compile-time enforcement.