"Stop Writing Dead Programs" by Jack Rusher (Strange Loop 2022)

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.

I agree with the author. I've written my fair share of typed code, but it is way more valuable to probe your program while running. I feel Jack Rusher puts it quite nicely in this talk: ▶ this video

> 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

Hi I think is in the hypothesis (I'm not sure) of that we have edition made by the pdp 11 keyboard developer and tooling that's old and design whiout introspection in mind showcase in this video, the video is really cool but little bit long ▶ this video

I think we might potentially be looking at this backwards. There is a great talk by Jack Rusher [1] on why having really slow iteration loops and being too disconnected from running programs creates a desire for theorem proving because it becomes the faster way to arrive at a correct solution. I am of the belief that we need to return to modifying live environments instead of sending code through a lengthy build pipeline. Instead of trying to make live environments secure and durable we got scared and now we have modern CI/CD. [1] ▶ this video

> 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

> 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

It's pretty much impossible to explain to people what it's like to work in a CL environment. A good presentation on what we're missing: ▶ this video

I believe this to be an artifact of our current paradigm of software development, which is based purely around static "batch processing" where the software can't be molded easily. (I didn't want it to come off as a plug, so I didn't add it to my original message, but I'm working on something to solve that.) To get a better idea of what I think is the better approach, check out these talks: Tudor Gîrba - Moldable development - link Jack Rusher - Stop Writing Dead Programs - ▶ 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

Your "unpopular rant" (or one pretty much like it) has 376k views and 12k likes on youtube![1] (Recommended watch, not least for demystifying the origin of vi's navigation keys and the choice of ~/ for /home/you.) 1: ▶ this video (link jumps to 16:52)

Very cool! This is something Jack Rusher cries for in his talk "Stop Writing Dead Programs" ▶ this video