Lobsters Interview with Sjamaan

Sep 2026 - Alex Alejandre

Peter Bex (website) is a CHICKEN scheme maintainer and professional Clojure developer. We got to know each other on IRC over a few months and discussed: CHICKEN Scheme and its 6.0.0 release Scheme’s community and standardization process Postgres, the horrors of MySQL and (default) SQLite Clojure My ongoing core contributions mainly focus on the numerical tower code, keeping the in-core copy of the irregex library up-to-date with the upstream version (of which I’m a co-maintainer), squashing bugs and the odd security fix. I enjoy deep diving into odd corners of a code base to get a better understanding and then improve any weirdnesses I find. - His CHICKEN About

2026年9月 - Alex Alejandre

Peter Bex（个人网站）是一位 CHICKEN Scheme 的维护者，也是一名专业的 Clojure 开发人员。我们在 IRC 上认识并交流了几个月，讨论了以下话题： CHICKEN Scheme 及其 6.0.0 版本发布 Scheme 的社区与标准化进程 Postgres、MySQL 的种种弊端以及（默认的）SQLite Clojure 我目前的核心贡献主要集中在数值塔（numerical tower）代码上，保持内置的 irregex 库副本与上游版本（我是该库的共同维护者）同步，修复 Bug 以及处理一些零星的安全补丁。我喜欢深入钻研代码库中那些奇怪的角落，以获得更深入的理解，并改进我发现的任何怪异之处。——摘自他的 CHICKEN 个人简介

Beginnings

How’d you start computing? I started computing when I got an old hand-me-down C64 which came with a “learn BASIC” book targeted at kids. Of course, I wanted to write my own computer games (which I never ended up doing). Later I got a real PC for my birthday and discovered my BASIC knowledge sort of transferred (with QBASIC in DOS).

起步

你是如何开始接触计算机的？ 我接触计算机始于我得到的一台二手的 C64，它附带了一本面向儿童的“学习 BASIC”书籍。当然，我当时想编写自己的电脑游戏（虽然最终没能实现）。后来，我在生日时得到了一台真正的 PC，并发现我的 BASIC 知识在某种程度上是可以通用的（通过 DOS 下的 QBASIC）。

Later, I learned about C, which I used for many years until at uni there was a course which taught Lisp (Scheme, really). We started with The Little Lisper/Schemer, and then SICP. I had a “functional programming course” before that which I almost flunked because it just didn’t make any sense (they used Concurrent Clean, because obviously teachers use their own language to teach regardless of its qualities - a common fault in academia). But the Little Schemer finally made it click. The teacher also showed how to implement objects using nothing but lambdas which I found awesome.

后来，我学习了 C 语言，并使用了多年，直到大学里有一门课程教授 Lisp（实际上是 Scheme）。我们从《The Little Lisper/Schemer》开始，然后是《SICP》。在此之前，我上过一门“函数式编程课程”，差点挂科，因为它完全讲不通（他们使用的是 Concurrent Clean，因为老师显然倾向于用他们自己的语言教学，而不考虑其质量——这是学术界常见的毛病）。但《The Little Schemer》最终让我豁然开朗。老师还展示了如何仅使用 lambda 来实现对象，我觉得这太棒了。

I actually studied AI before all the LLM bullshit. I much preferred the cleverness of the classical AI algorithms like A* search and genetic algorithms, but I haven’t really used them much in practice, only for my studies. I keep thinking I should use a GA for something, but no real use case so far. But even back then it was clear that neural networks were the future, though I found them boring because it’s just a bit of math (which I initially barely understood) and it’s basically a black box. I’m still grateful I studied AI because that’s the reason I came into contact with Lisp.

实际上，在所有这些 LLM 的炒作之前，我就学习过人工智能。我更喜欢经典 AI 算法的巧妙之处，比如 A* 搜索和遗传算法，但我并没有在实践中真正使用过它们，仅限于学习阶段。我一直想着应该用遗传算法（GA）做点什么，但目前还没有真正的用例。但即使在当时，也很明显神经网络是未来，尽管我觉得它们很无聊，因为那只是一些数学（我最初几乎看不懂）且本质上是一个黑盒。我仍然很感激我学习了 AI，因为那是我接触到 Lisp 的原因。

I might’ve looked into Lisp myself at some point (having been curious about it as one of the “foundational languages”), but I might not have had sufficient gumption to really dig in. After uni I got a job where they were using Rails in those somewhat early days (2006), so I learned Ruby as well. I liked learning Ruby and thought it was cool to see the power of Rails, but later got very frustrated with it because Rails really has strong opinions and my programming style didn’t seem fully compatible with it.

我可能在某个时候会自己去研究 Lisp（因为对它作为“基础语言”之一感到好奇），但我可能没有足够的毅力去深入挖掘。大学毕业后，我找到了一份工作，当时（2006 年）他们正在使用 Rails，所以我顺便学习了 Ruby。我喜欢学习 Ruby，也觉得 Rails 的强大功能很酷，但后来我对此感到非常沮丧，因为 Rails 的主观性太强，而我的编程风格似乎与它不太兼容。

CHICKEN & Scheme

Why CHICKEN? After that course, I tried using Lisp for every personal project. I first started with Scheme48 but it wasn’t very practical (though very elegant). I remember running into problems with the image not being big enough, running out of memory. I never really liked PLT Scheme (now Racket), coming into first contact with it through DrRacket, which felt very sluggish to me, though I do think DrRacket’s a cool alternative view of what an IDE could do. For example, when you hover over a variable and it shows you a line pointing to the origin of that variable.

CHICKEN 与 Scheme

为什么选择 CHICKEN？ 在那门课程之后，我尝试在每个个人项目中使用 Lisp。我最初从 Scheme48 开始，但它不太实用（尽管非常优雅）。我记得曾遇到过镜像（image）不够大、内存耗尽的问题。我从来都不太喜欢 PLT Scheme（现在的 Racket），我第一次接触它是通过 DrRacket，我觉得它非常迟钝，尽管我确实认为 DrRacket 对 IDE 的功能提供了一种很酷的替代视角。例如，当你将鼠标悬停在变量上时，它会显示一条指向该变量定义位置的线。

CHICKEN was a practical and fast system, with a good community and acceptable license (I had quite a distaste for GPL at the time). CHICKEN is also one of two (as far as we know) implementations that use the Cheney on the MTA technique explained here. There were lots of rough edges, but I think wanting to address those is what enabled me to get so deep into the core. If everything is perfect, there’s not much to do, really!

CHICKEN 是一个实用且快速的系统，拥有良好的社区和可接受的许可证（当时我非常反感 GPL）。CHICKEN 也是（据我们所知）仅有的两个使用此处解释的“Cheney on the MTA”技术的实现之一。它有很多粗糙的地方，但我认为正是想要解决这些问题的动力，让我能够深入到核心代码中。如果一切都很完美，那真的没什么可做的了！

So I started contributing to CHICKEN with some modest eggs (CHICKEN packages) at first, and eventually the core system. I mostly learned about Lisp internals by doing, mucking around with the CHICKEN core and trying things. I read Queinnec’s Lisp in Small Pieces, which deals with translation to C but leaves a lot undiscussed and distracts with OOP-heaviness. SICP has some good material. Then there’s Appel’s Compiling with Continuations, which is really short and to the point but still manages to be rather comprehensive; I love books like that.

所以我开始为 CHICKEN 做贡献，起初是一些简单的 eggs（CHICKEN 的软件包），最终参与了核心系统的开发。我主要是通过实践来学习 Lisp 的内部原理，通过摆弄 CHICKEN 核心并尝试各种东西。我读过 Queinnec 的《Lisp in Small Pieces》，它涉及了向 C 语言的转换，但留下了很多未讨论的内容，并且被过多的面向对象内容分散了注意力。《SICP》有一些很好的材料。还有 Appel 的《Compiling with Continuations》，它非常简短且切中要点，但仍然相当全面；我喜欢这样的书。

In general, I just enjoy hacking on the core, even if I don’t have that much time to do so these days. I have to stress that I’m a slow learner. Building my understanding of CHICKEN was a process of many many years, and there are still parts of the system I’m not that familiar with (although I know my way around enough to get up to speed if needed).

总的来说，我只是喜欢折腾核心代码，即使现在我没有太多时间这样做。我必须强调，我是一个学习缓慢的人。建立我对 CHICKEN 的理解是一个历经多年的过程，系统中仍有一些部分我不那么熟悉（尽管我知道如何找到方向，以便在需要时快速上手）。

What do those Lisp books lack? Compiling with Continuations has only a brief section on the runtime system, so it doesn’t go very deeply into e.g. garbage collection and data representation. Lisp in Small Pieces doesn’t go into continuation passing style, IIRC. And its data representation isn’t very optimized. I like to blog about cool techniques that are undiscussed nowadays. For example implementing weak references and how to GC them efficiently. Other stuff I rarely see discussed is how to do FFI and cross-module optimizations, separate compilation and cross-compilation (which only a handful of Schemes even support) etc.

那些 Lisp 书籍缺少什么？ 《Compiling with Continuations》关于运行时系统的部分只有简短的介绍，因此没有深入探讨垃圾回收和数据表示等内容。《Lisp in Small Pieces》据我记忆没有涉及延续传递风格（CPS）。而且它的数据表示也不是很优化。我喜欢写博客讨论当今很少被提及的酷技术。例如，实现弱引用以及如何高效地进行垃圾回收。我很少看到讨论的其他内容还包括如何进行 FFI（外部函数接口）和跨模块优化、独立编译和交叉编译（只有少数 Scheme 实现支持）等。

What’s Scheme to you? In general, Scheme, to me, is a very clean language with a minimal core which facilitates experimentation. This is the fundamental tension of the standardization process - production-quality Schemes tend to grow in size, and there is value in standardizing that. But that also takes away the minimalism which makes experimental implementations possible. For example, Felix Winkelmann (@Bunny351, CHICKEN’s original author’s talk about Scheme implementation) once started a Common Lisp (subset) implementation where he experimented a lot with types and flow analysis, resulting in CHICKEN’s type stuff.

对你来说 Scheme 是什么？ 总的来说，对我而言，Scheme 是一种非常简洁的语言，拥有一个便于实验的最小化核心。这是标准化过程中的根本矛盾——生产级的 Scheme 往往会变得臃肿，而标准化这些特性是有价值的。但这同时也剥夺了使其能够进行实验性实现的极简主义。例如，Felix Winkelmann（@Bunny351，CHICKEN 原作者关于 Scheme 实现的演讲）曾经启动过一个 Common Lisp（子集）实现，他在其中对类型和流分析进行了大量实验，最终形成了 CHICKEN 的类型系统。

What are your thoughts on the overall Scheme ecosystem, R7RS, SRFIs vs. implementation-specific libraries etc.? A few imple (Note: The original text ends abruptly here.)

你对整个 Scheme 生态系统、R7RS、SRFI 与特定实现库之间的对比有什么看法？一些实现…… （注：原文在此处中断。）