
Exploring Emacs - happy4crazy
https://www.hackerschool.com/blog/11-exploring-emacs
======
babarock
I was a Vim exclusive for several years before shifting cold turkey to emacs
on the 01/01/2012 (first new year resolution I keep in my life!). My
impression is still the same as day one: I will never reach the same _raw_
speeds in emacs as I used to (and still do) in Vim, but I've never had as much
fun exploring the inner workings of any system as I have with emacs.

The functions described in the article are crucial. You should rewire your
brain to type them every time you ask yourself a question.

Generally speaking, Unix is very good at self documenting. Whether it's text
editors (vim/emacs), shells (bash, zsh, ksh) or just plain man pages (did I
mention the _info_ pages for GNU tools?), the systems are great at holding
their own full documentations.

I cannot recommend enough adopting the reflex of checking the local
documentation before opening your web browser and hitting Google.

~~~
happy4crazy
This is my experience exactly. I was a long-time, very fast Vim user, but I
wanted to play around with Proof General, an Emacs mode for using proof
assistants like Coq[0]. Emacs slowly cannibalized my Vim usage from there: I
started using it for Clojure, and was amazed that M-. would hop me into
Clojure source. Then I started using it for Erlang, and then I started taking
all my notes in org-mode. It wasn't until I was already pretty comfortable in
Emacs that I learned about the C-h commands.

For pure text surgery, I'm still significantly faster in Vim. But the fact
that Emacs is so explorable/discoverable is just so fun!

[0] <http://proofgeneral.inf.ed.ac.uk/>

~~~
__david__
> For pure text surgery, I'm still significantly faster in Vim.

Have you tried viper mode or one of the equivalents? I'm curious how it
compares to vi. One of the things that I (as a long time Emacs user) have
considered is to switch to using viper mode, even though I only know vi enough
to edit a config file on a remote machine that lacks emacs. But I'm curious
how it compares to the real thing, and if it gets in the way of ancillary
emacs stuff (I can't live without stuff like "C-x v =" and "M-/").

~~~
Hemospectrum
Skip viper-mode and go straight to evil-mode, which is based on modern Vim
rather than classic vi. It even supports a plugin system, so that missing
features and popular extensions (like surround.vim) can be reimplemented with
ease (<https://github.com/timcharper/evil-surround>).

The difference between Vim and the original vi is pretty huge. Just as an
Emacs user might be stymied by the missing Lisp support in uemacs or zile, a
habitual Vim user leans on stuff like text objects and visual selections,
which were never even a twinkle in Bill Joy's eye.

------
__david__
This is one of the huge reasons I'm still an emacs user in the face of so many
IDEs. Until you've used emacs for a while you don't realize that emacs was
built in emacs and has great tools like the ones described in the article to
poke around its innards.

Writing emacs lisp in emacs is a joy because it's so easy to drill down when
things don't work and figure out exactly what is going on.

------
drothlis
An extended tutorial using Emacs's self-documentation:
<http://david.rothlis.net/emacs/howtolearn.html>

Random testimonial: «The guide has been extremely helpful and without it, I
wouldn't be making the switch from vim. I particularly like that you present
just enough information about various tools that I can use them productively,
while referring to the excellent built-in docs. A lot of the programmer-
critical tools have good documentation, but no "here's the bare minimum you
need to know not to go back to your more comfortable environment" guides.»

~~~
happy4crazy
Your guide was indeed very helpful when I was getting to know Emacs. Thanks!

~~~
drothlis
That's great to hear -- thanks. :-)

------
hollerith
The features that make Emacs self-documenting are superbly done.

I wish other software systems emulated them.

Another example: if you write "(funcall " (or if the insertion point happens
to be an existing call to "funcall") and then hit C-h f, Emacs prompts you
with "Describe function (default funcall)". If "funcall" is the function you
wanted documentation about, you do not have to write out "funcall" again --
you just hit enter at the prompt.

------
jbp
How Emacs changed my life by "matz"

[http://www.slideshare.net/yukihiro_matz/how-emacs-changed-
my...](http://www.slideshare.net/yukihiro_matz/how-emacs-changed-my-life)

------
webreac
C-h k C-h k gives me: C-h k runs the command describe-key, which is an
interactive compiled Lisp function.

It is bound to C-h k, <f1> k, <help> k, <menu-bar> <help-menu> <describe>
<describe-key-1>.

I have no link to the source file. I am running version 23.1.1

~~~
drothlis
You don’t have the elisp sources installed. If you're on a unixy system, use
your system’s package manager to install the "emacs-el" package.

~~~
webreac
emacs23-el. Thank you very much

------
rustc
Serious question: If you switched from Vim to Emacs, and are happy with it,
how fast/slow are you in Emacs for pure text manipulation (moving lines,
changing text within quotes, joining lines, etc)?

~~~
Derbasti
Frankly, not quite as fast. But much faster in a lot of other interactions
such as note taking, organizing stuff, writing structured text, interacting
with git, using REPLs, using shells and many more.

------
numbnuts
Emacs' help system is fantastic and is one of my favorite things about it. But
I had no idea you can navigate to the C source code too. That makes me so
happy. :D

------
jaequery
could you guys explain why vim is faster in text editing than emacs?

~~~
Derbasti
Because you use single keystrokes instead of chords. Most editing actions are
single keystrokes im Vim. This is especially true for complex things such as
macros or command repetitions. In a way, this lends itself better to muscle
memory. At times, you will do terrifically complex things in Vim without even
knowing how you did them. This does not happen to me in Emacs as much.

But then again, my Emacs is growing with me and with every tweak I do it is
becoming more of an extension of my mind and my particular way of working.
This is not something I experienced in Vim.

~~~
PuercoPop
Although I agree with your explanation I always wonder if using something like
keychord in emacs could allow me to move as seemlessly around the text in
emacs as in vim.

P.D.: Also something the the . command in vim is only posible due to the mode
switching being an implicit start macro/end macro.

~~~
Derbasti
In my experience, fluidity of simple commands is not much of a problem,
because muscle memory will take care of that eventually anyway.

However, C-x C-S-8 is certainly a more complex move than qq.

And the one for recording a macro to a register is even more complex. So
complex in fact that I don't remember it. Hence I use those commands less
often.

But the flip side is that something like occur or REPLs or magit or org-mode
offer different benefits that you can not quantify in keystrokes as easily.

I guess there are different kinds of fluidity. To my mind, Vim is unmatched in
low-level text manipulation fluidity. Emacs optimizes for a kind of higher
level work flow fluidity.

Maybe Evil is the answer. But my brain has seemingly disparate modes for Vim
and Emacs that are weirdly incompatible to each other.

Also, it helps to reimplement your favorite commands in Emacs. For example, I
have M-s and M-r bound to something like f/F in Vim. Similarly, M-o and C-o
act like o/O.

~~~
aerique
You really should put powerful commands like macros on easier keys. I think I
used something like this (although not on F1):
<http://emacswiki.org/emacs/KeyboardMacros#toc6>

------
olgeni
"In Soviet Russia..."

