This is a cool anecdote about something that happened to me last week. I'd love to hear similar anecdotes where people who use Emacs (or Vim, or other software sophisticated enough) were able to combine its features in unexpected ways.
One lovely little thing: since everything is a buffer, autocomplete has more to work with. Specifically I'm thinking of hippie-expand's `try-expand-dabbrev-all-buffers`, which just uses all buffers as sources for 'expansions' for what's currently written. So you type "thi" -> M-/, and because another buffer has "thing-you-want", it is able to complete what you wrote out to "thing-you-want".
This is straightforward when you just think of buffers as being source files in your IDE, but it's not limited to that - you can also complete from a dired buffer, or your compiler output buffer, or your REPL. So you can get a filename to expand, even though no source code file actually contains that filename. If instead of dired and compile-mode you were using a separate file manager, and a separate terminal window to compile, you'd have text in three separate programs and no expectation that the text editor in your IDE would be able to see the other two.
Oh, yes! This is something I use all the time, and it's so natural (I've been using Emacs and dabbrev for about 2 decades now) I don't even think about it.
Changing buffers works just fine in keyboard macros.
So sometimes I'll prepare one buffer with a list of lines that are basically meant to provide input to a macro for editing another buffer and have the macro constantly jump back and forth between them. (E.g., move to a spot in the "edit" buffer, jump over to the "input" buffer, kill the next line, jump back to the "edit", yank that line, etc.)
"Kill" text in a "rectangle" and save its contents
C-x r k
Switch to the scratch buffer (think there's a missing RET at the end)
C-x b *scr C-I
"Yank" the "rectangle" saved in the first command
C-x r y
Moves to the start of the buffer and sets a "mark"
M-<
Literals that are entered at the start of the buffer
(+
Move to the end of the buffer
M->
Another literal
)
Executes the buffer (or at least the LISP expression at the cursor). Note the scratch buffer allows you to type arbitrary LISP stuff and execute it with C-j.
C-j
So, suppose the initial buffer contained
1
1
2
3
Then the scratch buffer would get turned into
(+1
1
2
3 )
And when executed this would add the list of numbers and look like this:
> Switch to the scratch buffer (think there's a missing RET at the end)
In vanilla emacs you need a RET, but I bet that like many people, OP's using a mechanism that will just select the matching item if there's a unique match, rather than the built-in buffer selection mechanism.
I use ido (with flx-ido for fuzzy completions), and it works for me as stated: C-i in the minibuffer runs `ido-complete`, which selects the unique completion if there's only one. (By default, that is, this is emacs and so of course there's a variable `ido-confirm-unique-completion` that you can set to customize this behavior.)
I don't think they were trying to be. Broadly, those are the key bindings to copy a column of characters (presumably numbers) paste them into the `scratch` buffer and sum them, give or take some assumptions
