KCL part 1: units https://lobste.rs/s/9sfaxt #plt
https://www.ncameron.org/blog/kcl-part-1-units/
#plt
Reversing abstractions: an existential crisis https://lobste.rs/s/zojcpq #plt #unix
https://www.humprog.org/~stephen/blog/research/recovering-abstraction.html
Implementing the transcendental functions in Ivy via @abnv https://lobste.rs/s/vyrmdi #plt
https://commandcenter.blogspot.com/2026/01/implementing-transcendental-functions.html
Visitor as a sum type (2018) https://lobste.rs/s/kqt13j #plt
https://blog.ploeh.dk/2018/06/25/visitor-as-a-sum-type/
Cousot on Abstact Interpretation
How easy it is to construct an APL or K-like programming language
(by Mohammed Jamal Alrujayi)
This was an amazing article I found on the orange site published just last week. He notes that although APL and K are of the Harvard school of languages, while Lisp is of the MIT school, they are fundamentally related in their minimalism and in how the languages are structured around a single data type: Lists for Lisp, and vectors/matrices for APL. The two schools of thought were unified in the K programming language by Arthur Whitney:
On kparc.com (his personal website) he listed K’s lineage simply as “lisp and apl,” linking to Iverson’s Turing paper and Perlis’s lyrical programming.
I didn’t know much about Iverson’s family of languages (#APL, J, #BQN, K, and so on), but seeing it embedded in just a few lines of code in a high-level language like #Python suddenly makes it so much easier to understand. The syntactic keywords are basically composed of either infix operators of mapping operators, the data (constants or variables) are like leaves of the syntax tree. So all you need are three lambdas: “atom” checks if it’s argument is a number, monad serves as apply or map depending on the type of it’s arguments and abstracts it into a lambda, and “dyad” constructs an infix operator abstracted into a curried lambda. You only need those three rules!
atom = lambda x: isinstance(x, (int, float, str))
monad = lambda f: lambda x: f(x) if atom(x) else list(map(monad(f), x))
dyad = lambda f: (lambda x, y: f(x, y) if atom(x) and atom(y)
else list(map(lambda yi: dyad(f)(x, yi), y)) if atom(x)
else list(map(lambda xi: dyad(f)(xi, y), x)) if atom(y)
else list(map(lambda xi, yi: dyad(f)(xi, yi), x, y)))
Now I definitely want to try this as Scheme macros!
#tech #software #Lisp #APL #KProgrammingLanguage #JProgrammingLanguage #ProgrammingLanguages #PLT
Why not tail recursion?
https://fed.brid.gy/r/https://futhark-lang.org/blog/2026-01-20-why-not-tail-recursion.html
Why not tail recursion? https://lobste.rs/s/mpnhom #plt
https://futhark-lang.org/blog/2026-01-20-why-not-tail-recursion.html
Type-safe eval in Grace
https://fed.brid.gy/r/https://haskellforall.com/2026/01/typesafe-eval
Crane is a new extraction system from Rocq to C++ https://lobste.rs/s/cvqjov #c++ #ml #plt
https://github.com/bloomberg/crane
How would software look if hardware had stopped improving long ago? https://lobste.rs/s/wlxuty #ask #plt
Type-safe eval in Grace https://lobste.rs/s/kvviy0 #plt
https://haskellforall.com/2026/01/typesafe-eval
The Jule Programming Language https://lobste.rs/s/tq0yv5 #plt
https://jule.dev/
computing with projected light: the folk computer https://lobste.rs/s/eyunqw #video #design #plt #visualization
https://youtu.be/hrXEtG3JILo
Are arrays functions?
https://fed.brid.gy/r/https://futhark-lang.org/blog/2026-01-16-are-arrays-functions.html
Autovectorization seems like a cool way to write cross platform SIMD code. But does anyone know of solutions to the insight issue? If I were to write a function which relies on autovectorization, wouldn't I literally have to 1) compile with every compiler + compiler settings + CPU arch + platform I wanna support, 2) disassemble all resulting binaries, 3) read analyze the assembly code to verify that it's vectorized how I expect, and 4) repeat for every change?
RE: https://fantastic.earth/@abnv/115905408192306242
“I finally finished my Implementing Co series of posts. It took me only four years and nine months.”
few technical writers share @abnv ’s clarity. i wish he’d write a book. go enjoy the last chapter of his fantasy language, #plt nerds. ❤️
kip: A programming language based on grammatical cases of Turkish
Client Info
Server: https://mastodon.social
Version: 2025.07
Repository: https://github.com/cyevgeniy/lmst