The Courage to Be Disliked by Ichiro Kishimi and Fumitake Koga is very quickly shaping up to be this book for me.
It's probably highly unpalatable to modern Western sentiments (e.g., one of the chapter titles is "Trauma Does Not Exist") but it otherwise has really original lessons that I haven't seen articulated elsewhere, despite the sometimes overly formal English translation.
A bit crass these days, but this is probably where Reddit-style fake accounts will probably shine. Maybe a mix of manual work + judiciously crafted chatGPT prompts?
I've thought about fine tuning a GPT using stylometry to sound like specific HN users. You'd have to do that if you want it to succeed, since otherwise it'll all sound same-y.
Got my HP50g in my last year of uni (physics) and I only wish I'd learned to depend on it sooner. Would have been fun figuring out calculus wizardry with a lisp-like language from the get-go.
Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach
It's a rigorous but chatty textbook in the style of Spivak but written by someone who is sensitive to applied maths. I would not have survived my astrophysics classes without it.
I wonder what it would take to bring these things to Clojure. Its REPL experience is miles ahead of non-lispy languages but I do feel a pang of grass-is-greener whenever I hear about CL's debugging tooling. Hell, the JVM has a great debugger as well (or so I hear), so why is that difficult to port over?
Same, I've been torn between learning Clojure—which I think is brilliantly designed, but I dislike its reliance on the JVM and exceptions vs conditions/restarts—and Common Lisp, that comes with a standard library that feels older than POSIX and C, but a REPL experience that is unrivalled and decades ahead any compiled language.
I decided to go with Common Lisp for its REPL and inside-out development experience, and just hope there's someone that will eventually take Clojure and CL, and fuse the two together.
The more I dive into Lisp and Smalltalk, the more I am convinced we are in the stone age of computing. We have reached the local maximum of UNIX and the basic abstractions over machine code we call compiled languages.
There's some good debugging tooling for Clojure as well. A recent entrant is https://github.com/jpmonettas/flow-storm-debugger and of course there's the estabilished pretty full featured debugging features in CIDER [1](Emacs), Calva [2] (VS Code) and Cursive (IntelliJ, using std Java JDI debugging). And for barebones tracing from REPL there's goo old clojure.tools.trace. And a bunch of others (sayid, postmortem, cljs-devtools for ClojureScript together with browser debugger, etc)
What CL has over Clojure is mostly the condition system I think.
I would love to know the answer to this! It sounds like something that would be both possible and very useful. I assume there's a good reason why it can't be done based on how the Clojure / JVM execution model works, but I don't know nearly enough about it to hazard a guess.
You can just use e.g. Intellij's debugger with Clojure? What exactly do you need ported?
Personally, I don't really see the value though. I prefer to create modules of mostly pure functions, testing them in the REPL using Rich comment blocks.
One thing is that when an unhandled exception occurs the clojure program is terminated, where as lisps usually does allow one to restart the program at the point of exception after examining what caused the exception and changing the values of local variables to rectify that. Can the intellij debugger do that?
You wrote 'feetback' instead of 'feedback', and Colemak is the only popular layout (vs Qwerty and Dvorak) where 't' and 'd' are right next to each other.
Submission statement: this is an old article about UIs that aren't organised in space like desktops are but in time.
With the advent of tools like git and nix, one wonders if the time is now ripe for chronology-centered interfaces. I frequently find myself wishing to have an integrated VCS in my filesystem (or at the very least, being able to treat my entire computer as if it were in a git repo so I can roll back changes) even if I'm on NixOS where you're basically on your own for files in your home directory.
It doesn't even have to be a complete replacement: you can imagine a tiny slider than can allow you to walk through the previous states of your desktop to see how your work evolves over time. But I guess (bi)temporality and immutability are still new ideas, and even in such a fast-moving field like ours it takes a while for certain things to trickle down from ivory towers.
It's probably highly unpalatable to modern Western sentiments (e.g., one of the chapter titles is "Trauma Does Not Exist") but it otherwise has really original lessons that I haven't seen articulated elsewhere, despite the sometimes overly formal English translation.