Last weekend I noticed a slew of fascinating papers pop up all over the place. I'd started searching for information on a couple different programming languages as I needed some inspiration for Fancynote, my own little language experiment. Each time I'd set off on my search I'd come across a paper written for something called HOPL4, on the history of the language I was looking into.
This may be due to my self-taught computer science education but I barely ever hear about the histories of the tools I'm using. By and large the things I'm reading about the field are firmly rooted in the now.
That's why it was so exciting to come across these papers discussing the languages not in terms of features or benchmarks but situated in the history of their developments, products of people and decisions and context. 1
Clojure was created by one person, Rich Hickey, and is stewarded by him to this day. There are a couple striking things about it's development process. First is the absolute focus on practicality. Clojure was conceived of as a hosted programming language, meaning it would run on top of some other already widely distributed system, initially the Java Virtual Machine (more on this later). This avoids all sorts of issues for a new language, like getting people to understand it's concepts and bulding a library ecosystem.
Second, Rich Hickey's process in developing it is fascinating. He talks about it in Hammock Driven Development which I highly recommend (though I need to give it a rewatch). He "considers forming a rationale a significant part of the work of making Clojure", it was a language created after a lot of careful consideration.
On the other side of the language creator spectrum lies smalltalk. Instead of one clean lineage stewarded by a benevolent dictator we have countless branches and revisions. One incredibly interesting derivative I'd never heard of til this weekend, and which barely saw the light of day, is Strongtalk. It's name comes from the fact that it has optional strong static typing, differing from every other small talk I've seen. 2.
I really should spend a whole newsletter talking about smalltalk (after doing months of research probably), it's a fascinating language. It's underpinned by a notion of objects and messages, and builds up programs entirely from those two concepts. And it has a strong tradition of entire GUI environments for editing smalltalk code, entirely written in smalltalk itself, and naturally extensible by the programmer.
Last week I set myself the task of figuring out how to handle new-lines in the code, and well, I did it in the simplest way I could, just filtering out newlines if I am executing code, and keeping them in if just rendering. It works for now, but it 100% will lead to problems down the line.
To be honest I'm kinda stalling on Fancynote. All this research into languages (and my other rabbit-hole, 2D graphics rendering, which connects I promise), has filled my head with so many different ideas and potential research directions. I'm in dire need of some Rich Hickey style hammock thinking.
I'm begining to feel the pain of the lack of cohesion in Fancynote, both in it's vision and it's code. Well, the former's going to take some time, but I can definitely make progress on the latter.
Anyways back to the book. It's a wonderfully written guide to making a programming language that toes the line between theory and practicality. In short exactly what I need as a reference for hacking on fancynote!
For next week I want to read more of it and clean up the fancynote codebase. I love some good refactoring and it feels great to set time explicitly for it. That's all y'all, thanks for reading!