181
Compiling Pattern Matching
This post intends to provide a brief overview of the algorithm described in Luc Maranget’s “ Compiling Pattern Matching to Good Decision Trees ”.
Topics /
Programming Languages
The most popular blog posts about programming languages on Hacker News. 246 posts.
182
183
Porting Libyaml to Safe Rust: Some Thoughts
The following is a loose collection of thoughts that came up while porting unsafe-libyaml to safe, idiomatic Rust, which may be useful to someone else who is considering "rewriting it in Rust", as the ancient journeyman prayer goes.
184
A simple core.async job system in Clojure
In my off time (and my on time, for that matter) I've been working on this quirky thing I've called Scinamalink (sounds like 'skinamarink'). Scinamalink lets customers send Magic login links to their users with a single REST API call. If you don't know what a magic
185
Is Fortran “A Dead Language”? (2022)
Some C++ folk seem to think so, but they're wrong!
186
Common Lisp's block / return-from and unwind-protect
I was just chatting with Ben Titzer on Twitter about control flow in his Virgil language (which is cool and you should definitely check ...
187
188
Exploring biphasic programming: a new approach in language design
I’ve noticed a small but interesting trend in the programming languages space. I’m not sure how novel it is, but this pattern, which I’ll refer to as “biphasic programming,” is characterized by languages and frameworks that enable identical syntax to express computations executed in two distinct phases or environments…
189
Techniques for safe garbage collection in Rust
This will be the first in a series of posts describing different design decisions made writing two Rust crates:
190
Bootstrapping a Forth in 40 lines of Lua code
Author: Eduardo Ochs eduardoochs@gmail.com https://anggtwu.net/ https://www.lua.org/gems/ https://www.lua.org/gems/selected.html Version: 2008feb17 Listings: http://anggtwu.net/miniforth/miniforth5.lua http://anggtwu.net/miniforth/miniforth5.out Preprint version: https://anggtwu.net/miniforth/miniforth-article.pdf
191
OCaml Syntax Sucks (2016)
OCaml's let … = … in … is very confusing. When nested, you can't tell how it's nested.
192
Traits are a local maximum
An expose on Implicits and Local Coherence
193
Bicameral, Not Homoiconic
Parenthetically Speaking: Articles by Shriram Krishnamurthi
194
Unsafe Rust is harder than C
Or: The Most Expensive Linked List I’ve Ever Written
195
Garbage collected smart pointers in Rust via concurrent cycle collection
Scheme to the Spec is a series on the more complex, often overlooked aspects of programming language implementation.
196
A tiny self-remaking C program
In my last post I floated the idea of writing a slow, edit-prone shell script instead as a self-rebuilding C program.
197
The C++ Killers (Not You, Rust)
All the “C++ killers”, even these which I wholeheartedly love and respect like Rust, Julia, and D, help you write more features with fewer bugs, but they don't much help when you need to squeeze the very last FLOPS from the hardware you rent. As such, they don’t have a competitive advantage over C++. Or, for that…
198
Parsing: The Solved Problem That Isn't (2011)
Updated (2014-10-24): If you find this article interesting, you may be interested in the follow-up article on an editor for composed programs .
199
200
Let futures be futures
In the early-to-mid 2010s, there was a renaissance in languages exploring new ways of doing concurrency. In the midst of this renaissance, one abstraction for achieving concurrent operations that was developed was the “future” or “promise” abstraction, which represented a unit of work that will maybe eventually…
201
Using Drop for safety in Rust
A deep dive into Rust’s vec::Drain and its Drop implementation as an example of how ownership prevents subtle bugs—memory and otherwise!
202
MiniJinja: Learnings from Building a Template Engine in Rust
Learnings from building MiniJinja, a template engine in Rust
203
Borrow checking without lifetimes
This blog post explores an alternative formulation of Rust’s type system that eschews lifetimes in favor of places . The TL;DR is that instead of having 'a represent a lifetime in the code, it can represent a set of loans , like shared(a.b.c) or mut(x) . If this sounds familiar, it should, it’s the basis for polonius…
204
205
Recursion, continuations and trampolines (2017)
How is tail recursion different from regular recursion? What do continuations have to do with this, what is CPS, and how do trampolines help? This article provides an introduction, with code samples in Python and Clojure.
206
How GCC and Clang handle statically known undefined behaviour
Recently, we had a discussion in our team about undefined behaviour (UB) in C. For those unfamiliar: We say that a program has undefined behaviour when we write code where the language specification doesn't define what should happen during execution. That means compilers can do whatever they like if they encounter…
207
Compiling a Lisp (2020)
Overture to our small Lisp to x86-64 compiler
208
Python Modern Practices
Good development practices for modern Python
209
I added some optimizations to my compiler that turns Lisp into JavaScript
Smaller programs that do less work.
210
Needle: A DFA Based Regex Library That Compiles to JVM ByteCode
Many years ago, Kragen complained about the implementation and performance of Java regexes , and suggested that an implementation that emitted JVM bytecode could perform better. It's been a minute, but I'm happy to report that complaining on the Internet has served its purpose.