Strange Loop Conference
9 HN recommenders · recommended in 11 months, 2022–2025
43:04 · 468K views · Oct 11, 2022
Jack Rusher's Strange Loop 2022 talk argues that most programming languages are still designed around punchcard-era assumptions. He makes the case for live, interactive programming environments, drawing on Lisp, Smalltalk and REPL-driven development.
HN returns to it constantly as the talk on live programming and what modern tooling is missing, though a few found it too much.
20 comments from Hacker News
Live development is still so under-explored, and is just so exciting to work with. One of my favorite talks is "Stop Writing Dead Programs" ( this video ) and touches on a lot of what could be in terms of live development. Lisp is very well-suited to live development due to code being data, but live development doesn't need to be lispy. I built a live development extension for Love2D which lets you do graphics livecoding (both lua and glsl) in real-time - every keystroke updating the output, (if a valid program). [LINK] Here are some (early) demos of things you can do with it: [LINK] So many cool things once you break down the barrier between editor and running program. I've also asked myself the question of, what would a language look like that was natively built for live development, and built out a prototype - though it's definitely a sandbox so haven't posted it anywhere yet, other than demos on mastadon.
> eventually gave up because -- well, Lisp, right? That would be an utterly misguided approach. Lisp is amazing, you just need to give it a chance to be appreciated. Accept it with all its flaws and immense power, surrender to the malleability of the structure, dynamism of types and its homoiconic nature and you may find something incredible that would last you a lifetime. You need to conquer two aspects - structural editing and REPL. Learn basic structural editing idioms - find a way in Emacs (or whatever editor of your choice) for automatically balancing parentheses, for slurping, barfing, transposing s-expressions, cutting and pasting them. That will make all your programming like literally assembling lego blocks - something every other (more traditional) programming language promises yet somehow fails to deliver. Then learn eval commands - get into the habit of REPL-driven development. With Lisp, you don't have to wait for compiler, transpiler, linker, linter, etc., you can just write anything and see how it runs in-place. Often, you don't even have to save anything to a file. Relevant video to watch: this video - Stop Writing Dead Programs by Jack Rusher. Try modern Lisp dialects - there's plenty to choose from depending on what kind of tasks you're trying to solve - Clojure, Janet, Fennel are all very fine candidates. Clojure is especially nice if you need to deal with data. In my opinion it's hands down the best medium for data manipulation - nothing even comes close to t
> simple examples comparing Lisp ... that illustrate the benefits of using Lisp over another language It depends on what you're trying to get out of it. For example, you can grab a simple code of some React components with JSX and ask ChatGPT to write it in Hiccup (Clojure). That would show you how s-expressions can reduce the syntax boilerplate and make it smaller. You can do the same thing with Lua and Fennel - Fennel code would be much shorter and cleaner. However, without proper understanding and using structural editing and connected REPL, you probably won't see any benefits right away. Lisp code is not the best to be read off the "dead medium" - paper or screen. It's better when you have a connected REPL because it allows you to evaluate every single expression on the fly. Instead of trying to understand what (foo x y z) means, you can evaluate it and immediately see the results. With a connected REPL, you can evaluate them separately (individually), or together. Good talk of relevance: "Stop Writing Dead Programs by Jack Rusher" this video Next step in understanding the benefits of Lisp code is learning structural editing. Because everything is a symbolic expression, you can easily move, transpose, change, and replace parts of your program. Instead of rewriting a function of seemingly arbitrary syntax constructs, you'll be dealing with well-structured forms that you can easily move around. No, it not the same, better or worse than using refactoring features of your IDE wi
> trying to understand what's happening in code is even harder It's different in Lisp because you basically program a thing from the inside out, meaning that you don't just read the code from top to bottom. Instead, you constantly evaluate expressions and expand macros while going through it. It's practically like playing a game, and there's a good amount of fun. People often dismiss Lisps (Clojure, CL, Fennel, Racket, etc.) after reading Lisp code without any connected REPL and often don't even grasp what makes it so awesome. It's like disliking food after seeing it for the first time in a cooking show on TV. Good talk of relevance: "Stop Writing Dead Programs by Jack Rusher" this video
Because we live in a free society and smoking is a proper right. It is unhealthy and largely outdated habit but if you want to light a cigarette, you can. Programming in C++ is also an outdated habit. There are better languages, better technologies, and there are generally better ways to create software than writing code, compiling the code, replacing std::abs with abs (real issue, these are different functions) and recompiling the code again. But writing in a horrible language is a proper right as well. People write in Brainfuck for fun and good for them! Jack Rusher sums up what better programming looks like in his Strange Loop talk this video