Hacker News Reader

Comment by rezistik | Hacker News Reader

As a dev who's always used Sublime/Atom and sometimes Vim, what's the benefit of Emacs for Lisp?

Slime is really amazing. It provides tons of features of which here are a few (these work with Common Lisp, I have no clue if they work with Clojure).

Inspector[0]: You can click on objects to "inspect" their values. This includes hash-tables, arrays, and closures. In addition you can execute arbitrary code on these objects at any time, even while a program is running.

Trace Dialog[1]: Most Lisp implementations already provide a way to trace procedures. Tracing normally consists of printing the input and the output as each traced procedure is called. Slime provides something much more powerful. Slime's Trace Dialog is similar to trace in that it creates a buffer of the input and output, but instead it is provided in a tree menu format. In addition it is possible to inspect all of the values in the Trace Dialog with the inspector.

Debugger[2]: When an error is thrown in a program, a window pops up which provides several things. You can click on a stack frame to see all of the variables in that frame and then inspect those variables with the inspector. You are also provided with a list of restarts[3]. In addition, you can return a value from a given stack frame, or retry a procedure call on the stack frame (you may have modified the definitions of some procedures before you did this), and have the program continue as if nothing had ever happened.

There are also many other features, such as the ability to macroexpand code by clicking on it, to look up every procedure which calls a given procedure, to look up every place in which a given variable is set, and many other awesome features.

[0] http://common-lisp.net/project/slime/doc/html/Inspector.html

[1] http://common-lisp.net/project/slime/doc/html/SLIME-Trace-Di...

[2] http://common-lisp.net/project/slime/doc/html/Debugger.html#...

[3] http://en.wikibooks.org/wiki/Common_Lisp/Advanced_topics/Con...

That actually sounds a lot like Smalltalk.

Also the editor does not crash if the (lisp) environment becomes unstable (hangs, crashes, etc.) - Such things rarely happen, but they might - for example in Lispworks (which has emacs-like IDE (very nice) but runs the lisp threads in the same process as the editor).

Restarts are feature of Common Lisp, for which SLIME only draws a powerful interface. Your ability to return a value/retry a call from a given stack frame is just a bunch of default restarts of your CL implementation. What is really awesome is that you can add your own restarts to the interactive debugger. Or have them execute automatically.

I recommend those who are not familiar with conditions/restarts to read up a bit on them. This is something like exception handling, but an order of magnitude more powerful.

> Your ability to return a value/retry a call from a given stack frame is just a bunch of default restarts of your CL implementation.

Almost. Restarts and value/retry on a stack frame are mostly unrelated - Restarts are only the UI for implementation specific features. Common Lisp provides no feature to retry an arbitrary stack frame. This is all implementation specific functionality provided by SOME implementations.

I can speak about Clojure support for Emacs a bit, but I don't know how much of this Sublime or Atom can do.

I like the cider+nrepl workflow myself. You can edit your code, reevaluate it, and test it without having to restart your JVM. As you can imagine, this really speeds up development.

Also, though I haven't quite grokked all the barfing and slurping yet, paredit has really become a huge part of my code writing and editing in Emacs for Clojure code. I am on the cusp of getting barfing and slurping working for me now ;)

There's quite a lot of technology that allows you to write lisp/clojure very well in emacs. Some that come to mind,

- Swank/Slime (Lisp inferior modes) that allow you to write lisp, evaluate within the editor, see your results in a buffer. Offer auto complete, refactoring, debugging et al.

The more recent nrepl and cider modes for Clojure build on top of slime/swank and offer extremely great tools to write code as well. If you ever wanted to have the REPL running on the side and have great interop between code in a file and the REPL - these modes are great. Imagine their power when you can connect into a running webserver and debug on the fly from within your editor.

- A lot of original emacs plugins like paredit have now been ported to other platforms like Sublime. Also, emacs itself is written in lisp, which makes it a first class language it supports at its very core.

Each lisp varies dramatically in its semantics. Just because emacs is written in e-lisp does not mean it has first class language support for every other lisp. Would you say that vim has first class support for every language with block & statement based languages?

Agree with your high level point. Mine isn't that because it's written in e-lisp, emacs supports every other lisp. The fact that it's written in e-lisp makes it very extensible, and some standard things like C-x C-e to evaluate forms et al, which were originally developed for and are the standard for e-lisp, have been adopted for all other lisp modes as well. The very fact that the editor is written in a lisp makes it expose useful functionality this is useful in other lisp contexts.

Aside from all the other reasons other people already listed, there is a one fundamental benefit. Emacs is not just an editor, it's a Lisp runtime with text-editing functionality bolted on top. Lisp is natural for Emacs at all levels of complexity - from the fact that it's easy to work with Lisp code using Lisp to the Emacs community, composed in a big part of Lispers. Lisp just fits Emacs.

Emacs is pretty much a built in REPL primarily written in Lisp.

Slime

Reply on news.ycombinator.com