151
Evolution of Rust Compiler Errors
Blog about programming stuff.
152
Clojuring the web application stack: Meditation One
In a land bereft of a canonical "killer app" web framework or two, one must think about the what, why, how, where of all the moving parts. Out here, one must become a student of web framework architecture in addition to web application architecture. For here, in Clojure-land, the two are one. ☯
153
Why engineers can't be rational about programming languages
The neuroscience of why we make million dollar decisions based on identity, not data.
154
LSP client in Clojure in 200 lines of code
I wrote a small LSP client, it was kinda neat so I’m sharing it
155
Implementing Forth in Go and C
I first ran into Forth about 20 years ago when reading a book about designing embedded hardware . The reason I got the book back then was to actually learn more about the HW aspects, so having skimmed the Forth chapter I just registered an "oh, this is neat" mental note and moved on with my life. Over the last two…
156
Compiling a Lisp: Lambda lifting
first – previous
157
A years-long Turkish alphabet bug in the Kotlin compiler
Logic vs language: how a Turkish alphabet bug played a years-long game of hide-and-seek inside the Kotlin compiler
158
Problems with Go channels (2016)
Update: If you’re coming to this blog post from a compendium titled “Go is not good,” I want to make it clear that I am ashamed to be on such a list. Go is absolutely the least worst programming language I’ve ever used. At the time I wrote this, I wanted to curb a trend I was seeing, namely, overuse of one of the more…
159
Hacking Coroutines into C
A while ago, I was part of a team developing embedded software. The software was deeply rooted in state machines - dozens of them—spread across multiple functions. While this architecture is common in embedded development, especially for systems without an operating system, I started to question: Is this really the…
160
Several core problems with Rust
I used to call myself a Rust hater, but really I was doing it just to compensate for the perceivable fanboyism e.g. Rust tops on stackoverflow surveys as most-loved language. There are many reasons to hate C++, and I hate C++ too. Lots of people were waiting for a better programming language, but got Rust instead.
161
Error handling in Rust
A blog, mostly about programming
162
Scala 3 Migration: Report from the field
April 30, 2024. I decided to dedicate a week to migrate our main project at work (a multiplayer mobile game server in production for over 4 years) from Scala...
163
Blacksmithing and Lisp
A blog about computers, functional languages, Lisp, and Scheme.
164
Making C and Python Talk to Each Other
How to Use Python in C
165
166
Dynamically patch a Python function's source code at runtime
written by Eric J. Ma on 2025-08-23 | tags: python runtime llm security namespace compilation execution functions toolbot monkeypatching
167
Zig Error Patterns
Although I try to make good use of the debugger, I am quite used to print-based debugging, especially for unit tests. I wanted to explore some tricks to improve print-based debugging, and also incorporate the debugger more.
168
A Common Lisp jq replacement
Title says it all, I seriously dislike jq 's convoluted, impossible-to-remember ad hoc DSL that instantly joined heaps of misery like CMake and gnuplot in my heart. It should really have been a library with a CLI wrapper around eval in a well-known scripting language like Python.
169
Parameterized types in C using the new tag compatibility rule
C23 has a new rule for struct, union, and enum compatibility finally appearing in compilers starting with GCC 15, released this past April, and Clang later this year. The same struct defined in different translation units (TU) has always been compatible — essential to how they work. Until this rule change, each such…
170
Response to "Ruby Is Not a Serious Programming Language"
[5 min read] The question Sheon Han poses — “Is Ruby a serious programming language?” — says a lot about what someone thinks programming is supposed to fee...
171
A Look at Rust from 2012
Recently I was scrolling through brson’s Rust quote database and stumbled upon a link to the official Rust tutorial from the very beginning of 2013. It says Rust 0.6 in the corner, but it lists many things that were removed in 0.6, so it’s likely closer to 0.5. I heard tales of old Rust before, but not of how the…
172
Resizable structs in Zig
In this post I will make the case for the concept of a “runtime resizable struct” in Zig. I will then design an API by exploiting Zig’s powerful comptime functionality.
173
The cost of Go's panic and recover
TL;DR ¶ Some of the wisdom contained in Josh Bloch’s Effective Java book is relevant to Go. panic and recover are best reserved for exceptional circumstances. Reliance on panic and recover can noticeably slow down execution, incurs heap allocations, and precludes inlining. Internal handling of failure cases via panic…
174
Golang's big miss on memory arenas
When your software team needs to pick a language today, you typically weigh two factors: language performance and developer velocity.
175
A possible future of Python in the browser
My Python code was too slow, so I made it faster with Python. For some definition of “Python”.
176
177
178
My Ideal Array Language
The fundamental units of computation available to users today are not the same as they were 20 years ago. When users had at most a few cores on a single CPU, it made complete sense that every program was written with the assumption that it would only run on a single core.
179
A surprising enum size optimization in the Rust compiler
Enums are one of the most popular features in Rust. An enum is a type whose value is one of a specified set of variants.
180
Understanding Memory Management, Part 5: Fighting with Rust
This is the fifth post in my planned multipart series on memory management. You will probably want to go back and read Part I , which covers C, parts II and III , which cover C++, and part IV , which introduces Rust memory management. In part IV, we got through the basics of Rust memory management up through smart…