Modern IDEs don’t improve the feedback loop much unfortunately, more often it’s quite the opposite. They are slow, bloated and distracting. Some of them might be good at renaming one’s variables as part of their refactoring offer, but otherwise the situation is quite often bleak.

SBSL+SLIME+Emacs usually put one in the flow state in no time. That’s what keeps amazing me and keeps me productive.

And then, Claude seems to be quite alright discussing tricky Common-Lisp-related stuff.

For vim users, there's vim-slime:

https://github.com/jpalardy/vim-slime

I don't know if it's as powerful as the real thing, but it allows you to "send" your current vim line or paragraph to a tmux instance running a lisp interpreter, essentially. Very useful.

I've been waiting for ages for a Lisp that allows me to develop in one running system, creating minimized images with a tree shaker to distribute parts of the system for production when needed, and that never came (at least not with an affordable license, I don't know about the commercial Lisps). People recommend Smalltalk for this but that's not a Lisp. Eventually, I've switched to Go because if I have to write individual files in Emacs anyway, I can just as well use a more static language.

I’ve read a few scheme books over the years, and recently bought p.g’s book…

Though because I’ve had nothing to actually apply it to, it just gets forgotten about - that was until I decided to go all in on Emacs again about a year ago. And fancy that - I’ve written so much lisp (Elisp) in the past few months that even diving into Emacs extensions is t daunting anymore for me.

Want to get started? Force yourself to use it every day. Throw yourself in the deep end - start from a vanilla Emacs setup, and each time something bugs you, stop and figure it out (what’s the function, variable, face, etc that needs changing, or do you have to write a few function to get what you want done) - it’s a friggen superpower!!!

I've been writing Lisp code off and one since the 80s. The standard for Common Lisp has to be sbcl but the REPL is pretty minimal. The available packages tend to be more limited than Go which I've been using a lot lately. I did find a way to have a more functional REPL and also have access to all the Go packages by writing SLIP (https://github.com/ohler55/slip). Yes I know this is a plug for SLIP and if that offends anyone I apologize. The reasons mentioned for developing it are valid though and I've managed to use Lisp for almost all the data mining and processing tasks.

For people that use Lisp extensively, do you find the chording requirements of parentheses (shift-9 or shift-0) annoying? It feels like very bad ergonomics, considering how frequently the characters are used.

Do you use a keyboard with mappings to make it easier? Rely on the editor to insert them for you?

i use slimv instead

i think the powerful feature is not (only) merely sending code to repl

but the suggestion for function's parameter as the function is updated to repl

for example: (defun xyz (a &option b &rest c &key d) ) ;then send this with ,d (vim+slimv) to swank server

the next time i type (xyz ... vim status bar conveniently states: (xyz a &optional b &rest c &key d)

both happen whether i start typing (xyz in repl or in vim; that's it, the function parameters show up as suggestions in repl and in editor

Way too heavy. Just install sbcl & vim.

Mark: So how do I get started in Common Lisp?

Nolan: That's the neat thing—you don't.

One of the interesting and, depending on your perspective, perhaps unfortunate side effects of LLM-assisted development becoming the standard is that LLMs almost completely disincentivize choosing an unpopular language for serious work. Due to the much higher volume of training data, you're better off using TypeScript, Go, or Rust (or Swift if you're in Apple-land or Kotlin if you're in Android dev hell). Those languages with an LLM will make you far more productive than even an "expressive" language like Lisp.

Plus there are complete, modern IDEs for those that let you get started right from the jump, rather than having to build your own IDE out of Emacs and assorted parts before you can actually develop your application.

It's pretty much the same number of bracket-type characters as other languages, and both () and {} require the use of the shift key. Only counting the parentheses and curly braces:

  (defun hello (name)
    (format t "Hello, ~A!" name)) ;; 6 parens, 6 shift keys

  def hello(name):
    print(f"Hello, {name}") # 4 parens, 2 curlies, 6 shift keys

  void hello(char* name) {
    printf("Hello, %s\n", name);
  } // 4 parens, 2 curlies, 6 shift keys

No real difference for typing.

It is bad ergonomics only on modern keyboards. Back in the day, there were keyboards with "lower case parentheses"[1].

Same case for vi - the : key was in a different place, and no Shift necessary[2].

Nowadays, I use a bespoke layout (in software) that solves the above two problems, among others. My number row is inverted, so parentheses become lower case, and I put the colon key next to 0 and Enter next to P.

[1]: http://xahlee.info/kbd/lisp_keyboards.html

[2]: https://en.wikipedia.org/wiki/ADM-3A#Hardware

A civilized language deserves a civilized layout[1]:

     [{ 1| 2= 3~ 4+  5<  6>  7^ 8& 9% 0* ]} /\
        bB yY oO uU  '(  ")  dD nN gG vV qQ #$ @`
        hH iI aA eE  ,;  .:  tT rR sS cC zZ 
        kK jJ xX wW  -_  ?!  mM lL fF pP

[1]: https://github.com/binarybottle/engram

  Parinfer: Simpler Lisp Editing (shaunlebron.github.io)
  168 points by harperlee on Jan 20, 2025 | hide | past | favorite | 32 comments

probably not worse ergonomic because i type '(' with left pinky and right ring finger and ')' with left pinky and right pinky whereas {} [] etc, i have to use the very same overworked right pinky to distinguish two keys next to each other.

i always have problems with keys that have no obvious dedicated finger position like the middle vertical columns especially 6 and b and of course keys reachable on the right pinky, especially \ and =

I mean, double quotes and curly brackets also require using the Shift key, as do the at sign, number sign, dollar sign, and ampersand. The brackets are a small enough part of the code that it doesn't matter.

And besides:

  print("Hello World");

requires just as much chording as:

  (print "Hello World")

My ring finger is always slightly sore due to typing ( so often. Not just in LISP but any programming language. I've been experimenting with mapping l; to () when the caps lock key is pressed. So far so good, but I haven't used it long enough to develop muscle memory.