To be clear, slime isn’t necessary.

Yeah, but that’s just complaining that just because we used to have flying cars we still should. We decided as a society to give up on flying cars. They’re gone. Move on with your (our) boring 2D lives.

Yes but we need you to make those points substantively, neutrally, interestingly—without swipes or putdowns: https://news.ycombinator.com/newsguidelines.html. If you just post grumpy one-liners we're going to get a flamewar, and the primary fault for that lies with the comment that starts it.

I know from many past comments that you have a ton of knowledge to share—it would be way better if you would explain some of that to the rest of us, rather than holding it back and just giving us a shallow version of your final conclusion, with a pointed end.

You don't. You run it in emacs. That's what they are saying.

SLIME is, but there is Slimv which is a SWANK client for vim:

https://github.com/kovisoft/slimv

(Never used it myself so can't comment on it beyond noting its existence.)

I have an article I wrote about how I did this, but may have lost it to time.

The short version is I have SLIME running inside Emacs, and my text files open in vim. I would just reload the changed file(s) when needed (originally with cl:load-file, then later with asdf, which is roughly "make" for lisp). I used slime similarly to how I would use gdb. It was a big improvement over using vim with the clisp[1] REPL both because SLIME was more powerful than the clisp repl, and because it worked with other implementations like CMU CL (which sbcl now is a fork of).

I mostly just used the menus for interacting with emacs, but since the shortcuts are listed beside commands, I did learn the more commonly used ones.

I continued like this for years until I discoveredevil-mode[2], which was the first thing close enough to vim to be usable for me (and even then I had to add a few keybindings that it was missing).

1: clisp is a specific implementation of common lisp, not an abbreviation

2: https://github.com/emacs-evil/evil

To provide a bit more context, most of SLIME is just Common Lisp code (https://github.com/slime/slime), with a bunch of Emacs Lisp code alongside to support interfacing with Emacs. But you don't need that Emacs Lisp code to take advantage of almost all of the functionality SLIME provides. For instance, if you want to know who-calls a function, there's some command in emacs to do it, but all that command is doing is just a bit of elisp code which sends a message to Swank (a server running inside Common Lisp) and Swank invokes some native CL code to figure that out and return the results, then finally a bit of elisp code presents the results in some way. Vim can do the same thing just fine with vimscript/python (what the Slimv plugin uses) or otherwise, the bulk of the work in figuring out the list of callers of some function is done by the CL code (and CL implementation itself).

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

It doesn't do everything, it doesn't do it as elegantly, but it works

It’s not. You can use any editor. Emacs just happens to have a package called slime that helps - I’m told. I’ve been using just lisp+emacs w/o slime for decades. To be clear, except for slime, which as above is optional, any editor will do just fine.

> why a family of languages should be this dependent on a specific editor...

The language isn't, but SLIME is because emacs isn't just an editor, it's a platform and system that people develop applications on top of. And the community was already there, using emacs, to continue with that option.

You can emulate vim key bindings in Emacs with ViperMode.

> I'm wondering why a family of languages should be this dependent on a specific editor...

As mentioned by others, its not. But Emacs is also a Lisp runtime. People who are attracted to Emacs eventually learn some Lisp (Emacs Lisp, closer to CL than Racket et al) or were attracted because of Lisp in the first place. As a result, the overlap between CL devs and Emacs users is naturally higher than that for other editors. This translates into people developing more and better tools for their editor, and higher popularity usually translated into more and better tools (with obvious exceptions).

As mentioned by other commenters, SLIME can be used with Vim too, if that's your thing. But just like SBCL, Emacs is kinda of de-facto editor of choice, not by force, but by love of its users :)

I've done the vast bulk of my CL work using just vi. Specifically, I was doing the typical "reload the lisp file" life cycle, rather than the interactive "just redefine this defun" style of development. Even when I used Lispworks, it was "save file, reload it" style of development.

I used CLISP because it had GNU readline. (e) to edit my file, (l) to reload it, and off to the races (I wrote those trivial defuns). No packages, no imports, no asdf. Everything in CL-USER.

I did switch to emacs for one simple reason: tab to reindent. Other than that it was the most basic of emacs use (load file, save file, ^s to search, cmd-XCV for cut and paste, pgup, pgdn). No Sexpr navigation, no buffer juggling, none of that, no lisp integration whatsoever outside of paren matching and the tab to indent.

SLIME is a third–party tool that integrates with Common Lisp; it isn’t part of the language. With most Common Lisp implementations you can just use the repl to call (inspect foo) to see what slots foo has and their values. It will probably be a little clunky since drilling down into the details might require you to type numbers at a prompt. Meanwhile SLIME presents the same information in a UI, so you can click on things (or type the numbers if you prefer).

It just happens that SLIME is a pretty well designed UI (the acronym stands for Superior Lisp Interaction Mode for Emacs, so I guess that was the goal). It’s miles ahead of what you get from most other languages, even C++, but most of what makes it so great comes from features that were already present in the language implementations. It also combines very well with other advanced Emacs packages such as Paredit.

Interestingly, SLIME is implemented as a network protocol to allow for remote debugging, so you can implement a new UI for it any way you want. I’ve never used it, but you might check out SLIMV instead. https://www.vim.org/scripts/script.php?script_id=2531

Join me vim brother and don't settle for forcing yourself to use emacs while developing in CL when you don't have to! You even have two vim options! https://github.com/kovisoft/slimv and https://github.com/vlime/vlime with a great comparison of the two: https://susam.net/blog/lisp-in-vim.html

Although Franz Inc supported Franz Lisp and developed Allegro Common Lisp, it is my impression they are distinct implementations. I can't find any hard evidence one way or another. Do you know?

They offer a more graphical development experience. Yes. Whether it is better than Slime, would need to be discussed. But the point is quite irrelevant in the moment, when you just cannot develop anything due to memory limitations.

Not if your lisp image exits even with simple programs.

Perhaps you can write some articles using them, showing how they're better?