Links

Blogs

• Justine Tunney's Web Page

  Author of 'cosmopolitan libc', 'blinkenlights', 'lisp with gc in 436 bytes' and 'actually portable executable' among many other things. Author is also known as 'jart'.

• eieio.games

• General Protection Fault

  • Let's Learn x86-64 Assembly! Part 3 - Arithmetic and Logic

• Matt Keeter

  Has an interesting blog and writes about for example CSG, rendering, statemachines and program synthesis.

  • The Prospero Challenge
  • QEF Explainer

• Evan Hahn

  Author: Evan Hahn

  • How I build software quickly
  • Takeaways from the Economist's style guide book

• iRi

  Author: Jeremy Bowers (jerf)

• Giles' blog

• The Observation Deck

  Author: Bryan Cantrill

  Writes about Rust, Oxide, Blogging among other things.

  • Falling in love with Rust

• Daniel's Blog

  Writes about mixed things. Uses many programming languages! Haskell, Lisp, Smalltalk, J, Prolog and probably others.

  • Choosing a Functional Language

• Max Bernstein

  Writes about compilers and many other things. A great source of inspiration!

  • Writing that changed how i think about PL
  • Compiling a Lisp: Instruction encoding interlude
  • Writing a Lisp, Part 0: Fundamentals

• Stephen Diehl

  Writes about many things and quite often.

  • Sci-fi Hidden Gems
  • dependent Types in 200 Lines of Python
  • Exotic Programming Ideas, Part 3 (Effect Systems)
  • Exotic Programming Ideas: Part 1 (Module Systems)

• The Log Book of Manuel Kießling

  Author: Manuel Kießling

  A blog, nice minimalist page design. Writes about infrastructure as code, aws, etc.

• This Is The Website of Gwern Branwen

  Author: Gwern Branwen

  Writes about many things, including web design and typography.

• krasjet

  Author: Krasjet

  Writes about many things. Such as A Visualization of Effectful Computations

• Ayaz Hafiz

  Author: Ayaz Hafiz

  Writes about types and computing theory, among other things.

• Laurence Tratt

  Author:: Laurence Tratt

  Personal page of Laurence Tratt. Blogs about research, compiler and programming language theory, video editing among other things.

  • Static Integer Types
  • Why Aren't Programming Language Specifications Comprehensive?

• xtao blog

  Author: Darius J Chuck (Home page)

  The xtao blog posts contain among other things:

  • Introduction to the LAST programming language
  • Encodings for numbers in lambda calculus

• the {λ way} project

  Author: Alain Marty

  The author experiments with functional programming and has created the programming language "lambda talk", among other things. Also experiments with web technologies to create interesting combinations of these two subjects. For example there is the lambda tank which is a sort of IDE running in a browser.

• lambduck

  lambduck isa functional programming language.

  An in-browser implementation of lambda calculus with direct input/output.

  imjakingit/lambduck

• IOCCC 2012/tromp Lambda interpreter

• the scapegoat dev

  Author: Manuel Odendahl

  Writes about software development and the writing process. Originally read Embedded programming is like web development and About Writing - RC - Day One and found them interesting.

• <antirez>

  Author: Salvatore Sanfilippo

  The creator of the Redis database, writes about software engineering, development methodology, open source ecosystems, distributed systems, among many other things. The blog goes back quite far and is a recommended read!

• Yoshiki Ohshima, Ph.D.

  • tinlizzie.org
  • Viewpoints Intelligent Archive

    We would like to collect and disseminate the interesting thoughts and ideas of Dr. Alan Kay. The Talks by Alan Kay page lists accessible movies, documents, and (soon) running simulations and demos linked with the talks and documents. As of now, the Talks page has most of the known recordings. Many of the movies have auto-generated transcripts. Some movies have transcripts that have been cleaned up and annotated by knowledgeable collaborators. The goal is to have clean transcripts for all the movies and to add annotations. We would like to have the simulations and demos Alan used in his talks so that readers can access them.

Blogposts

Some blogposts that was interesting to read.

• Little Languages Are The Future Of Programming

  I’ve become convinced that “little languages”–small languages designed to solve very specific problems–are the future of programming, particularly after reading Gabriella Gonzalez’s The end of history for programming and watching Alan Kay’s Programming and Scaling talk. You should go check them out because they’re both excellent, but if you stick around I’ll explain just what I mean by “little languages” and why they’re important

  The author also references the STEPS project.

• The Myth of RAM, part 1

  Explains why time complexity of memory access is not actually O(1). The the two following parts are also worth reading.

• Algebraic Effects for the Rest of Us

• AI and Programming Language Communities

  I think our higher intellectual processes can process the idea that there are many distinct people posting online, but our lower brains tend to treat all external online interactions with people not in our Dunbar circle1 as one amalgamated “The Internet Other”.

• 20 years of programming

  Author: Bernardo, Daniel Sidhion

  Unoffice hours

• Jordan Webb

  • Why Android can't use CDC ethernet

    This answers a question that has bothered me. It was fixed in 2023 and then reverted.

  • Hacker News

• Classical "Single user computers" where a flawed or at least limited idea

  Writes about the limitations of old "single user computers". Cruically they lacked isolation between software components. Mistakes in any component can bring down the entire system. Future computer systems needs stronger boundaries between components.

  Lobsters discussion

• On the benifits of learning in public

  Author: Giles Thomas

  A short nice blogpost about why it is a good idea to write about things that one is currently learning.

• It's still worth blogging in the age of AI

  Author: Giles Thomas

  I found this quote to resonate with me:

  The TL;DR: blogging isn't just about being read -- it's about learning and thinking, and having a durable proof that you can do both.

• Write to Escape Your Default Setting

  Author: kupajo

  Explains that writing can help clearing ones mind.

• WHY SPECIFICATIONS DON'T COMPOSE

  Author: Hillel Wayne

  Explains why specifications do not compose in terms linear temporal logic. It discusses the framing problem, fairness and stuttering. It also contains references to more material by the author on these topics.

• The ultimate compiler

  Author: Ben Lynn

  Interesting blogpost about lambda calculus, combinatory logic, Haskell, Scott encodings. The blog seems to contain many interesting posts and the author appears to provide good references to literature for those who seek to study the background material.

• Notes on structured concurrency, or: Go statement considered harmful

  Author:Nathaniel J. Smith

  Blogpost about structured concurrency. Describes how goto and go have similar properties and how structured control flow is related to structured concurrency.

• Andreas Kling - I like computers!

  Author: Andreas Kling

  The developer behind SerenityOS, blogs about SerenityOS C++ software development, also produces videos filmed during development.

• soc.me

  Writes a lot about language design.

  • x86 prefixes and escape opcodes flowchart
  • Soc codeberg
  • core Programming Language

• tree-shaking, the horticulturally misguided algorithm

  Author: Andy Wingo

  A blogpost about tree shaking, webassembly, compilation, partial evaluation. References the Hoot and Whiffle Scheme dialects.

• How to write a code formatter

  Author: Yorick Peterse

  A good explanation of the pretty-printing approach in "A prettier printer" by Philip Wadler.

• Lambda Calculus and Lisp, part 1 The Neo-Babbage Files

  A blogpost about the history of Lisp and Lambda Calculus. Provides plenty and interesting references.

Miscellaneous

• EchoLisp

  A Lisp that runs in a browser. It is described as follows (in the help section).

  EchoLisp uses worksheets stored in a notebook. Worksheets have cells. Each cell has an input field - named stdin -, an output field - named stdout -, and an optional plotter field (an HTML canvas). Functions and buttons are provided to create/open/save worksheets in the notebook (browser local storage), add/show/hide/remove cells in a worksheet

• Lambda Viewer

  A neat visualization of reduction of lambda calculus terms. Made by Hai (Paul) Liu

• Partnership for Advanced Computing in Europe

  The mission of PRACE (Partnership for Advanced Computing in Europe) is to facilitate the access to a research infrastructure that enables high-impact scientific discovery and engineering research and development across all disciplines to enhance European competitiveness for the benefit of society. PRACE seeks to realise this mission by offering world class computing and data management resources and services through a peer review process.

• Coding Machines

  Interesting short story about computers writing software by themselves. By Lawrence Kesteloot (2009). Read it!

SAT - Boolean satisfiability problem

• The SAT Game

  Ever heard of the SAT problem? This is a small game where you solve instances of the SAT problem. It is a bit like tic-tac-toe.

• The International SAT Competition Web Page

  The purpose of the competition is to identify new challenging benchmarks and to promote new solvers for the propositional satisfiability problem (SAT) as well as to compare them with state-of-the-art solvers. We strongly encourage people thinking about SAT-based techniques in their area (planning, hardware or software verification, etc.) to submit benchmarks to be used for the competition. The result of the competition will be a good indicator of the current feasibility of such approach. The competition will be completely automated using the SAT-Ex system.

  It is exactly what it says it is.

• SATLIB - The Satisfiability Library

  SATLIB is a collection of benchmark problems, solvers, and tools we are using for our own SAT related research. One strong motivation for creating SATLIB is to provide a uniform test-bed for SAT solvers as well as a site for collecting SAT problem instances, algorithms, and empirical characterisations of the algorithms' performance.

Smalltalk

• Cuis-Smalltalk
• OpenSmalltalk - The cross-platform virtual machine for Squeak, Pharo, Cuis and NewSpeak
• Smalltalk-80: the language and its implementation
• Smalltalk-80 Bits of History, Words of Advice
• Smalltalk - The Interactive Programming Environment
• Turning a Fun Project into Lessons: Programming a Space Shooter in Squeak/Smalltalk
• A gentle introduction to Pharo Smalltalk
  • Pharo architecture
  • Smalltalk history
  • Understanding Reflection
  • What is Reflection?
  • What is Introspection?
  • What is Intercession?
• Learn Smalltalk with ProfStef

  Seems to be broken as of 2025-06-10, "Cannot add self to a string.".

• Talks about Pharo
• Mooc Immersive Object Programming with Pharo
• Pharo Books
• Stef's Free Online Smalltalk Books

Articles

• Identifying and Correcting Programming Language Behavior Misconceptions

  Authors: Kuang-Chen Lu, Shriram Krishnamurthi

  Publication: ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages & Applications, 2024

  Download: PDF

• Church's Problem Revisited

  Authors: Orna Kupferman and Moshe Y. Vardi

  Source: The Bulletin of Symbolic Logic , Jun., 1999, Vol. 5, No. 2 (Jun., 1999), pp. 245-263

  Publication: Association for Symbolic Logic

  • Church's solvability problem
  • Tree automata

Software

• Node-RED

  Node-RED's goal is to enable anyone to build applications that collect, transform and visualize their data; building flows that can automate their world. Its low-code nature makes it accessible to users of any background, whether for home automation, industrial control systems or anything in between.

  This is interesting because it appears to be quite portable and unified. It can run locally, on certain devices and in "the cloud". That being said it is limited to places where Node.js can run.

• Erlang-RED - A Node-RED backend coded in Erlang

• FLENG - low level concurrent logic programm language

(Interesting) Programming languages

• The Unison language

  Nifty pure functional language with interesting ideas around distributed programming, representing programs as structured data, effect systems (algebraic effects) and more.

  Introduction to Abilities: A Mental Model

• Effekt Language: A language with lexical effect handlers and lightweight effect polymorphism

• Koka: A Functional Language with Effect Types and Handlers

• Roc: A fast, friendly, functional language.

• Ante: A low-level functional language

  For exploring algebraic effects, safe shared mutability, and other novel features.

Declarative machine description

How can we describe computers in a more declarative way? Hardware, virtual machines and programming languages etc. So that more components can be automatically created rather than written manually by a person. This section is about finding references to already published works.

Some tricky challenges in this area:

• How general should the machine description be? Does it only describe historical machines? How about hypothetical machines? Finite state machines? Turing machines?
• What language is used to describe the operations of the machine? Boolean logic over bits of the machine? Arithmetic over finite integers? Low-level register-transfer-lists (RTL)?
• Manu sub-problems are actually undecidable

• Automatically Generating Instruction Selectors Using Declarative Machine Descriptions

  A declarative machine description specifies properties of a machine using formalism that is independent of any particular tool or programming language. Properties of interest for code generation include the semantics and the binary or assembly-language representations of machine instructions. By design, a declarative machine description can be written by a machine expert who knows nothing about the internals of any compiler.

  In this paper, we evaluate only components related to instruction selection. Machine-dependent components that solve other important problems -- register allocation, stack-frame layout and calling conventions -- cannot be generated from declarative machine descriptions alone, even in principle; some knowledge of software convention is required. For that reason, these components are best retargeted using other techniques, as we have described elsewhere.

• K framework
• BURG
• Collberg C compiler knowledge extraction.
• Superoptimization
  • Denali superoptimizer (Joshi, Nelson Zhou (2006))

Rust

• Falling in love with Rust

Symbolic Execution

• Encoding Symbolic Expressions as Efficient Solver Queries
• Program synthesis with Z3

Turing Machine simulators

• tmsim - A fast turing machine simulator with graphviz export functionality
• Online Turing Machine Simulator

  This is a online simulator used in teaching at quite a few universities.

• Speed Machine - Fast GPGPU Turing Machine simulation This project lets you simulate lots of Turing Machines quickly on your GPU using CUDA
• How to simulate everything (all at once)
• Are Turing Machines Programmable?

  The difference between “program” and “machine” is “just” a matter of perspective1, and in any case it’s “just” a matter of terminology. But I’m a stickler for terminology, and thinking through this question led me to a dramatically faster Turing machine implementation. The rest of this post will walk through this line of thinking.

Declarative Programming

Prolog

Datalog

Neurosymbolic programming

Scallop

https://www.scallop-lang.org/ Scallop: From Probabilistic Deductive Databases to Scalable Differentiable Reasoning

Lobster

Lobster: A GPU-Accelerated Framework for Neurosymbolic Programming

Dyna

https://dyna.org/ https://github.com/argolab/dyna3 https://matthewfl.com/research#phd dyna-pi: Dynamic Program Improvement

PyNeuraLogic

PyNeuraLog lets you use Python to create Differentiable Logic Programs PyNeuraLogic documentation GitHub Beyond Graph Neural Networks with Lifter Relational Neural Networks

We demonstrate a declarative differentiable programming framework based on the language of Lifted Relational Neural Networks, where small parameterized logic programs are used to encode relational learning scenarios. When presented with relational data, such as various forms of graphs, the program interpreter dynamically unfolds differentiable computational graphs to be used for the program parameter optimization by standard means. Following from the used declarative Datalog abstraction, this results into compact and elegant learning programs, in contrast with the existing procedural approaches operating directly on the computational graph level. We illustrate how this idea can be used for an efficient encoding of a diverse range of existing advanced neural architectures, with a particular focus on Graph Neural Networks (GNNs). Additionally, we show how the contemporary GNN models can be easily extended towards higher relational expressiveness. In the experiments, we demonstrate correctness and computation efficiency through comparison against specialized GNN deep learning frameworks, while shedding some light on the learning performance of existing GNN models.

Things that have been read

• On How Long it Takes to Know if a Job is Right for You or Not

  You only get one career. Who are you ggoing to give your bacon to?

• A receipt printer cured my procrastination

Durable workflow software companies

• Temporal
• DBOS
• Inngest
• Restate

Things to read in the future

• SHRDLU: Procedures as a Representation for Data in a Computer Program for Understanding Natural Language
• Algorithms for Modern Hardware
• The Art of Computer Programming
• Introduction to Algorithms
• Performance Engineering Of Software Systems
• Programming Parallel Computers

• CompilerBook

• InterpreterBook

• CraftingInterpreters

• T3X

• T3X Books

• Breckyunits

• Danluu Nothing-Works

• Sci-fi Hidden Gems
• Understanding the World Through Code
• Automated transpilation of imperative to functiona code using neural-guded program synthesis

Constructive solid geometry

• Dual Marching Cuboids

• Dual Marching Cubes: Primal Contouring of Dual Grids

• Dual Contouring Tutorial BorisTheBrave.Com

Operating systems

• Dusk OS
• Collapse OS

Software

• zathura - a document viewer

  GitHub - pwmt/zathura: Document viewer ZATHURA A DOCUMENT VIEWER zathura is a highly customizable and functional document viewer. It provides a minimalistic and space saving interface as well as an easy usage that mainly focuses on keyboard interaction.

C programming language (blogposts, etc)

• some C habits I employ for the modern day

  Blogpost describing some methods for writing better C. A few things that in this blogpost where new to me, like WG14 N3037.

  Found via Lobsters

Mesh network implementations

• Reticulum GitHub

  The cryptography-based networking stack for building unstoppable networks with LoRa, Packet Radio, WiFi and everything in between. ... Reticulum is the cryptography-based networking stack for building local and wide-area networks with readily available hardware. It can operate even with very high latency and extremely low bandwidth. Reticulum allows you to build wide-area networks with off-the-shelf tools, and offers end-to-end encryption and connectivity, initiator anonymity, autoconfiguring cryptographically backed multi-hop transport, efficient addressing, unforgeable delivery acknowledgements and more.

  Zen of Reticulum

  In the IP world, an address is a location. It is a coordinate in a deeply hierarchical and static grid. If you move your computer to a different house, your address changes. If your router reboots, your address might change. Your identity is bound to your location, and therefore, it is fragile, and easily controlled. ... In Reticulum, an address is not a place; it is a Hash of an Identity. It is a cryptographic representation of who you are, not where you are.

• Yggdrasil Network

  Yggdrasil is a new experimental compact routing scheme. It is designed to be a future-proof and decentralised alternative to the structured routing protocols commonly used today on the Internet, as well as an enabling technology for future large-scale mesh networks.

Uncategorized (todo)

• Are arrays functions?

  From the Futhark language blog.

• Interconnected
• SidHion
• Where Lisp Fails: at Turning People into Fungible Cogs.
• Arcan as Operating System Design
• https://occasionallycogent.com/programming_isnt_coding/index.html
• https://news.ycombinator.com/item?id=35380742
• https://janet.guide/xenofunctions/

• CodeChecker

  A static analysis infrastructure built on LLVM.

• The Vine Programming Language

  A programming language based on interaction nets.

• XXIIVV - interaction nets

  Someones interesting wiki/blog. Interaction nets. Oscean. Uxntal.

  "This wiki is a digital playgraound and personal logging system."

  Author: Devine Lu Linvega

• An Illustrated Guide to Interaction Nets

  It is what the title says it is. Does a good job explaining interaction nets with simple diagrams and color.

• Kalyn: a self-hosting compiler for x86-64

  Interesting small self-hosting compiler for a Haskell-lite language.

• Maru

• uLisp: Lisp for microcontrollers

  A Lisp for microcontrollers indeed. Ported to many platforms.

• "The Secret Life of Programs" by Jonathan E. Steinhart

• "Build a Large Language Model (From Scratch)" by Sebastian Raschka

• www.marginalia.nu

  • Marginalia Search

• Feep! search

  • Why writing your own search engine is now easy

• Concurrent Programming with Harmony

  This book is intended to help people with understanding and developing concurrent code, which includes programs for distributed systems. In particular, the book comes with a tool called Harmony that helps with testing concurrent code. The approach is based on model checking [8]: Instead of relying on luck, Harmony will run all possible executions of a particular test program. So, even if a bug is unlikely to occur, if the test can expose the bug it will. Moreover, if the bug is found, the model checker precisely shows how to trigger the bug and will try to minimize the number of steps.

• permacomputing