
Ask HN: Resources to grok Emacs and use it well? - AnonC
With reference to the other post here (<a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=22875106" rel="nofollow">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=22875106</a>), I’m once again fascinated by Emacs and the following it has. I know vi (learned it quite sometime ago) and though I’m not a power user, I can do a lot of things in vi without putting in much effort or searching online for solutions.<p>So I’m here to ask for resources — text based tutorials, video tutorials and what not — that would help someone grok Emacs (from a novice level) and get into the Emacs way of doing things (including elisp?).<p>I would also like recommendations on what (package&#x2F;source) you consider as the best to install on macOS and on Linux.
======
kabdib
Emacs user here, it's been my go-to editor for about 40 years.

I have a few customizations, not many. My .emacs file is 63 lines long,
doesn't include any other files, and mostly just tweaks some key bindings and
turns off features that I don't like. The only modes I use are built-in ones
(e.g., C-mode, auto-wrapping text mode, etc.). I can't write elisp without a
reference manual, and I think that's okay.

I suggest:

\- not installing a bunch of random stuff until you're comfortable with the
core experience or you simply _have_ to adjust or disable something that bugs
you

\- just _using_ Emacs, and not customizing the crap out of it, ditto

If you haven't gone through the Emacs tutorial, it's how I learned it (at 300
baud, uphill both ways and in the snow -- not kidding about the 300 baud
thing, though).

~~~
smitty1e
I had to go to Spacemacs[1] for a few reasons:

\- Using the spacebar to invoke functionality is a massive physical boon to
usage. Stock emacs wrecks me from fingers to neck for an real amounts of
usage. This is a purely subjective weakness.

\- Spacemacs vi emulation. I drank the modal Kook-aid. Especially if one has
to SSH into headless instances in the cloud. vi is part of the POSIX standard,
so you know it's there and it's robust.

\- Spacemacs engineering. Great package integration in the form of layers.

[1] [https://www.spacemacs.org/](https://www.spacemacs.org/)

~~~
kalium_xyz
You can also just run evil mode for the vi emulation (its what spacemacs
does), spacemacs is the best emacs IDE though IMHO.

~~~
weaksauce
you definitely can use evil mode but you will find a lot of edge cases where
you have to configure something in some modes to behave sanely whereas with
spacemacs they have usually done all that legwork of anything you want to use.

~~~
kalium_xyz
You also have doom which is just evil and not space centric AFAIK

~~~
smitty1e
Doom has good reviews AFAICT

~~~
shanavasm
I switched to doom from spacemacs and quite happy with it. Lot more easier to
tweak that spacemacs.

------
smg
The biggest difference between Emacs and any other editor is that instead of
thinking about Emacs as an editor you need to think of Emacs as a programable
workflow enabler. Using Emacs without learning Elisp is like carrying a bike
on your shoulders instead of riding it. Once you get to the place where you
can confidently write Elisp to solve your problems, you will miss Emacs deeply
when you have to use any other application. You don't need to write extensions
and open source them for other people. All you need is the ability to create
Elisp code that does what you want exactly how you want it.

The best way of learning Elisp is reading the source code that is distributed
with Emacs. Do a git checkout of Emacs and read Elisp code written by Stefan
Monnier. Stay away from org-mode elisp - the quality of that code base is
highly suspect.

~~~
alexbanks
It's interesting to me that the top two comments (at the time of writing this)
are fundamentally opposite advice. Yours, to customize Emacs, vs. the second,
to basically not customize it at all.

~~~
asdf123wtf
My take on that is...

For those fundamentally interested in developing development environments,
coding tools, or making your editor your hobby, diving deep into emacs
customization is a reasonable thing to do. In other words, if creating things
like evil-mode or spacemacs excites you, a dive deep into emacs is a good
option.

For those who aren't interested in those things, try to actively avoid deep
diving into emacs. It will be an unfulfilling waste of time. There's no
magical developer productivity pot of gold at the end of that rainbow.

~~~
alexbanks
Definitely. I guess the interesting part specifically is that, if you aren't
the type to care about making a development env a hobby, why would you ever
even touch emacs?

------
NateEag
I'm a moderately experienced Emacser - been using it heavily since 2009 (first
encountered it in 2003). I have written a few small extensions and contributed
features and bug fixes to bigger ones.

Credentials established, I cannot recommend this tutorial enough:

[https://david.rothlis.net/emacs/tutorial.html](https://david.rothlis.net/emacs/tutorial.html)

He walks you through most of the core of what makes Emacs great by showing you
how to make a change to a project in the idiomatic Emacs way.

I would have learned it years faster had I started there.

Beyond that, learn basic Emacs keybindings via the tutorial, as others have
suggested.

I started in Emacs but installed evil-mode a few years ago and have never
looked back.

I do not recommend Spacemacs. Install the tools you want as you find you want
them, so that you know what's doing what, and so you have a decent chance of
knowing what broke things when something stops working.

Keep your packages in version control as part of your .emacs.d repository.
That keeps updates and deleted packages from screwing you.

Use "use-package" ([https://github.com/jwiegley/use-
package](https://github.com/jwiegley/use-package)) for configuring what you
install. It's written by one of the Emacs maintainers and will help you do
things right by default.

I'm not the best Emacser out there, but if you're curious, my config is on my
GitHub account:
[https://github.com/NateEag/.emacs.d](https://github.com/NateEag/.emacs.d)

Happy hacking.

~~~
smitty1e
Spacemacs is getting decent press here. How recently have you tried it?

~~~
lliamander
Spacemacs shows you what Emacs _can_ be, but adds a lot of complexity that
most people don't need.

I am currently a spacemacs user (holy mode, ya dirty heathens) and I like a
lot of the built in functionality. However, I think that I will eventually
build up my own config from vanilla.

~~~
smitty1e
The joy of emacs is that you really can configure it down to a gnat's booty.

------
mickael-kerjean
I made a tutorial series a few years back:

\- episode 0: introduction => [https://mickael.kerjean.me/2017/03/18/emacs-
tutorial-series-...](https://mickael.kerjean.me/2017/03/18/emacs-tutorial-
series-episode-0/)

\- episode 1: the basics => [https://mickael.kerjean.me/2017/03/19/emacs-
tutorial-series-...](https://mickael.kerjean.me/2017/03/19/emacs-tutorial-
series-episode-1/)

\- episode 2: org-mode => [https://mickael.kerjean.me/2017/03/20/emacs-
tutorial-series-...](https://mickael.kerjean.me/2017/03/20/emacs-tutorial-
series-episode-2/)

\- episode 3: interesting built in features =>
[https://mickael.kerjean.me/2017/03/21/emacs-tutorial-
series-...](https://mickael.kerjean.me/2017/03/21/emacs-tutorial-series-
episode-3/)

\- episode 4: installing plugins =>
[https://mickael.kerjean.me/2017/03/22/emacs-tutorial-
series-...](https://mickael.kerjean.me/2017/03/22/emacs-tutorial-series-
episode-4/)

\- episode 5: extending emacs with elisp =>
[https://mickael.kerjean.me/2017/03/23/emacs-tutorial-
series-...](https://mickael.kerjean.me/2017/03/23/emacs-tutorial-series-
episode-5/)

------
dimitar
Out of box / vanilla Emacs is pretty confusing doesn't include many popular
packages - that is why some pre-made configs are very popular. On the other
hand they might overwhelm you with features and very opinionated decisions.

If you want something close to what most users probably have setup and yet
still close to vanilla you can give Emacs Prelude a try:
[https://prelude.emacsredux.com/en/latest/](https://prelude.emacsredux.com/en/latest/)

I started with it, tried out the package selection, but then started a smaller
config from scratch with what I liked from it.

Also good links: [https://www.masteringemacs.org/reading-
guide](https://www.masteringemacs.org/reading-guide)
[http://emacsrocks.com](http://emacsrocks.com)

I don't believe one should restrict oneself to a single editor, but rather
follow a path of least resistance - Emacs is actually the path of least
resistance when you want to have a custom editing experience.

Overall I use four editors Emacs, vi, notepad++ and VS Code. Emacs when doing
Clojure or any other code so I can have something that is very convenient for
me, vi and notepad++ on machines where I don't want to setup a config or where
I do only simple text editing and VS Code where I would ocasionally need to
install a plug-in, but I don't need to use it often.

------
stakkur
I started using Emacs in earnest a few years ago, especially Org-Mode. At
first, I tried every customization I came across and loaded up my init file
with all the cool mods. But when things went wrong, I had no clue how to fix
them.

So after about a year I started over, resetting my config and using Emacs
customization over custom elisp writing to get a working init file. It helped
me learn a _lot_. This is the path I recommend: do small customizations using
Emacs' built-in features, then learn elisp later.

I learned a lot from this CS prof's videos, and it's a good, practical
learning path I'd recommend:
[https://www.youtube.com/watch?v=49kBWM3RQQ8&list=PL9KxKa8NpF...](https://www.youtube.com/watch?v=49kBWM3RQQ8&list=PL9KxKa8NpFxIcNQa9js7dQQIHc81b0-Xg)

If you're into writing, I maintain a list of resources for writing with Emacs:
[https://github.com/thinkhuman/writingwithemacs](https://github.com/thinkhuman/writingwithemacs)

~~~
shivekkhurana
I learnt from the same professor! His youtube series is well done.

------
rglullis
Saying that as someone using Emacs for at least 20 years: ignore the zealots,
get rid of this FOMO and ask yourself if there are 3 things missing from your
tools, things that you would like to have a better way of doing. For these
things, find someone experienced with Emacs and ask them to _show_ you how
they do it.

Unless your passion is in going meta and focus on _building_ the tools instead
of _using_ them, chances are that your current tools can do what you need just
fine.

~~~
shermanmccoy
You may just want something a bit snappier, say if you are coming from massive
bloatware IDE land?

~~~
rglullis
OP says he is experienced with vi, so it is not his case and I don't want to
be playing a game of "unlikely hypotheticals"

But, even if that were the case, the recommendation would be to either (a)
find a lighter alternative to the used IDE or (b) switch to an IDE that is
plugin-based to remove all of the "bloatware". At no point I would be telling
people that the first alternative for them to "be fast" is to join the church
of Emacs.

Fuck, I worked with junior developers who were more comfortable after I showed
them they could work with gedit + terminal instead of cargo-culting whatever
tool some nerdy senior used.

All I am asking is to not be like those photographers that spend more time on
forums discussing about equipment than actually taking pictures, or
audiophiles that focus so much on testing their equipment that they forget to
enjoy the music. Unless you are a camera maker/speaker designer/software tool
developer, focusing on the tools instead of the product is quite a stupid way
to live.

------
dizzystar
I've been using emacs for several years. If you saw my init file, you'd think
it was kind of funny. It's mostly to change the look from default to a black
box.

I do have some functions for connecting to databases, but for the most part,
there are no deep customizations.

I also have avy (think that's jump mode in vim), ldo for file browsing,
yasnippet (for snippets), multiple-cursors, and some language-specific major
and minor modes.

I mainly want to press C-c C-c and get my work done.

\------

As a general rule, emacs is pretty easy:

* C = basic

* M = more powerful

* CM = most powerful.

So...

* C-f = move forward one character

* M-f = move forward one word

* CM-f = move forward one bracket

A lot of things are sort of mnemonic:

* f - forward

* b - back

* r - rectangle

* s - search

* r - reverse search

The biggest thing to remember is that "yank" has the opposite meaning in
Emacs. In emacs, you can either "kill" (cut), or "copy", then you "yank" to
(paste). This is a function of how the Emacs "kill ring" works. This extends
to the above:

* C-y - yank the last item

* M-y - scroll back through the backlog of the kill ring.

Everything sort of falls out from this logic. If had to be completely honest
with you, I probably use 20% of the total functionality of Emacs. It's a huge
system, but I get my work done efficiently and don't sweat that I can't write
a bunch of elisp from memory.

~~~
AnonC
Thanks a lot for the simple explanation of the keyboard combinations (and the
underlying logic) as well as the part about yanking. As a vi user, that
might’ve tripped me up the first few times. But now I know better.

------
gct
If you're currently a vi user, I'd recommend spacemacs
([https://www.spacemacs.org/](https://www.spacemacs.org/)) to soften the
learning curve. It comes batteries included (as opposed to a stock emacs
install which requires a _lot_ of customization) and uses evil mode (vi
keybindings) by default. You can expose yourself to more and more of the emacs
way slowly.

Also emacs is largely self-documenting. Learn the keys for querying
documentation first thing. You can search for current keybindings, what a
given function _does_, etc all live while you're using it.

~~~
tams
Spacemacs is great, albeit slow at times.

On the evil front there is also Doom Emacs ([https://github.com/hlissner/doom-
emacs](https://github.com/hlissner/doom-emacs)) which is better optimized and
is still pretty full-featured.

~~~
aladine
Doom Emacs is a collection of many recommendated packages. For someone doesn't
use evil much like me, I can turn it off in the config file. Using Doom Emacs
is highly recommended for new comers to Emacs

------
sufyanadam
Emacs is very easy to learn. Just as you learn the key combinations for video
games, learning key combinations for emacs is really easy. Here are some steps
to help you:

1\. Go through the Emacs Tutorial. Just start emacs, put the cursor on the
text 'Emacs Tutorial' and hit enter. It will only take 30 mins max.

2\. Go through the first chapter in the Practical Common Lisp book here:
[http://gigamonkeys.com/book/lather-rinse-repeat-a-tour-of-
th...](http://gigamonkeys.com/book/lather-rinse-repeat-a-tour-of-the-
repl.html)

3\. By now you are comfortable navigating around and editing text, opening
files, running emacs commands with M-x etc... so you can now install packages
for syntax highlighting for your language etc... via M-x package-install
<enter> -> search for your language (usually LANGUAGE-mode), and install it.

4\. Use emacs to edit all your files for at least 1 day.

5\. Use emacs keybindings to navigate around in other apps if you're on Mac or
Linux, those are standard keybindings that work everywhere in Terminal, bash,
Textedit, Chrome, etc...

6\. Learn how to use vim, download a vim cheatsheet and have it handy for
reference, edit some files in vim (git commit messages will also do).

7\. Install evil-mode and edit your .emacs.d/init.el file to bind a key to
toggle evil-mode on/off

8\. In maybe one day max, you're very comfortable in emacs now, and may be
well on your way to writing your own extension functions. You're pretty much
an emacs expert by now, in only 2 days max!

9\. Try out different emacs configs. You can try mine out here:
[https://github.com/sufyanadam/.emacs.d](https://github.com/sufyanadam/.emacs.d)
it's setup for all major languages, Ruby, Python, React, JSX, etc... It also
has some soundboard keys bound, try C-c-n-m when you want to greet someone new
but don't want to be interrupted (you have to have mplayer installed on your
system for it to work).

~~~
AnonC
Thanks so much for the detailed instructions and the focus on the basics and
getting by step by step. It’s very comforting to read this, and it removes an
inherent fear that learning to use Emacs may be way too complex.

------
lainwashere
As others have said, the tutorial is the best place to start (C-h t). After
that for any other thing you need to learn in emacs the info will probably
have it (C-h i or M-x info). Emacs users usually spend much time configuring
their “operating system” till they’re satisfied, by modifying the init.el, but
you can get a popular config already made [0][1]. My biggest recommendation
after understanding how emacs works, if you use/prefer vi binds, is install
evil-mode [2]. It’s essentially a vi layer on top of emacs, and is very
functional.

edit: If you use MacOS, Yamamoto Mitsuharu‘s emacs-mac [3] is my
recommendation, as for linux the version from your distros package manager
should be apt. ;)

[0] [https://github.com/hlissner/doom-emacs](https://github.com/hlissner/doom-
emacs)

[1]
[https://github.com/syl20bnr/spacemacs](https://github.com/syl20bnr/spacemacs)

[2] [https://github.com/emacs-evil/evil](https://github.com/emacs-evil/evil)

[3] [https://bitbucket.org/mituharu/emacs-
mac](https://bitbucket.org/mituharu/emacs-mac)

------
podunktown
First, ask yourself if you really want to invest time in learning Emacs. It
probably isn't anywhere near the most important problem in your life, and
won't change it much. In fact it might make things worse because it will make
you aware of all the ways other editors are bad which didn't bother you
before.

That might be problem as teams standardize on newer editors with good
collaboration features, which don't exist or aren't as new-user friendly as in
Emacs. Some languages also don't have as good integration with Emacs as they
do with some IDEs.

That said, if you really want to learn Emacs, then

    
    
         - go through the tutorial
         - print out a good Emacs cheatsheet
         - Have piece of paper or notebook to make your own supplement/complement to the cheatsheet
         - use a Rosetta stone site if coming from Vim
         - Force yourself to use the keybindings to move, not the arrow keys or the mouse. It will take a few weeks to get comfortable with the basic movement.
         - Probably most important after the tutorial: learn all the help functions and their keybindings 
            - C-h ?
            - info
            - apropos
            - where-is
            - describe-key, describe-function, describe-mode, describe-variable, describe-bindings
            - find-library
         - understand how undo works
         - package-list-packages to install packages
         - Start a basic init.el:
           - (fset 'yes-or-no-p 'y-or-n-p)
           - (global-font-lock-mode t)
           - (transient-mark-mode -1)
         - Learn keyboard macros <--- Enormously useful
         - After you are more comfortable, install and configure helm
         - Read or browse the Emacs manual and the Elisp manual (in info)
         - Read the "Mastering Emacs" posts for more advanced features
         - Also Mike Zamansky's Youtube channel

------
psanford
I learned a lot about what to expect from emacs from Steve Yegge's blog posts.
Even though they are quite old now they still relevant.

[https://sites.google.com/site/steveyegge2/effective-
emacs](https://sites.google.com/site/steveyegge2/effective-emacs)

[http://steve-yegge.blogspot.com/2006/06/shiny-and-new-
emacs-...](http://steve-yegge.blogspot.com/2006/06/shiny-and-new-
emacs-22.html)

[http://steve-yegge.blogspot.com/2008/01/emergency-elisp.html](http://steve-
yegge.blogspot.com/2008/01/emergency-elisp.html)

------
ashtonkem
Spacemacs[0] is probably the best Emacs configuration for _discoverability_.
Not only do the maintainers rearrange key combinations to be thematically
grouped and mnemonically sane, they added/configured a really nice
discoverability layer into Emacs.

Even after close to a decade of Emacs usage, I learned more about Emacs using
Spacemacs for a month than I thought possible.

[0] [https://www.spacemacs.org/](https://www.spacemacs.org/)

~~~
celeritascelery
I second this. People who have been using emacs a really long time forget how
hard it is to get started. Especially when coming from a full featured editor
like VSC. Spacemacs made that transistion so painless for me and showed me
what emacs was capable of.

------
crispinb
Guidance here seems to fall into 2 camps - either (1) start vanilla or (2)
with one of the currently favoured packagings (Doom, Spacemacs etc).

I'd say it depends on what your aim is: (1) would be the way to go if you
primarily want to get fluent with emacs, _or_ are content to use tools you
already know for other work, and learn plain emacs gradually in the
background. (2) would be best if you want to get productive quickly using
emacs for real work, at the risk of a more occluded understanding of emacs per
se.

I'd put in a word for Prelude
([https://github.com/bbatsov/prelude](https://github.com/bbatsov/prelude)) as
a possible compromise, making emacs immediately usable but without putting
many layers between you and it. Some might consider it a little old-fashioned
however (no use-package etc).

I've used vanilla emacs on and off for many years for quick edits, but only
recently for actual programming (using Prelude, and prompted by learning
Clojure). It's taking over my computing lifestyle. I've laughed in the past at
people using it for email, but found myself using mu4e lately. Scary.

------
nickjj
Back when I was playing around with Emacs I found Protesilaos Stavrou's videos
to be quite good for getting a feel on how to accomplish specific things with
Emacs.

They are at:
[https://www.youtube.com/channel/UC0uTPqBCFIpZxlz_Lv1tk_g/vid...](https://www.youtube.com/channel/UC0uTPqBCFIpZxlz_Lv1tk_g/videos)

Most of the videos are focused on practical tasks you would want to do. It's
one of the few really good Emacs focused channels IMO.

------
rwnspace
This is what I've done the past couple weeks and it's going pretty well:

Start with plain Emacs. Print/write out the popular cheatsheets. Just make
sure you know how to exit, access the documentation, and move around the
windows/frames/buffers. Get Melpa & install some packages. Play with the
config, adding keybindings, figure out hooks and so on. Copy some elisp
functions from dotfiles on Github. Spam the documentation command on
everything. Get frustrated with how much tinkering you need to do to get the
crazy setups you've seen on blogposts. Stay motivated by consuming more
content about custom setups. Discover the magic of magit and parinfer and
dired. Look up some of the org-mode/PIM heroes on github, usernames: novoid,
alphapapa, karlicoss

Install Doom. Tinker with it a bit. Take notes of your learning in an org
file. Tinker some more. Go back to plain emacs for a bit. Then try spacemacs.
Go straight back to Doom because it's faster and you now understand enough
about emacs to be scared of spacemacs' layers.

Below are some links to help you along the way.

[http://ergoemacs.org/emacs/blog.html](http://ergoemacs.org/emacs/blog.html)

[https://sachachua.com/blog/](https://sachachua.com/blog/)

[https://www.gnu.org/software/emacs/refcards/pdf/refcard.pdf](https://www.gnu.org/software/emacs/refcards/pdf/refcard.pdf)

[https://orgmode.org/worg/orgcard.html](https://orgmode.org/worg/orgcard.html)

[https://cestlaz.github.io/stories/emacs/](https://cestlaz.github.io/stories/emacs/)

[https://www.youtube.com/watch?v=0g9BcZvQbXU](https://www.youtube.com/watch?v=0g9BcZvQbXU)

[https://zaiste.net/doomcasts/](https://zaiste.net/doomcasts/)

------
aceofspade
Emacs user here. I think Jethro Kuan's modern emacs:

[https://github.com/jethrokuan/emacs-
workshop/blob/master/mod...](https://github.com/jethrokuan/emacs-
workshop/blob/master/modern-emacs.pdf)

is pretty good as an introductory resource.

Disclaimer: I picked up Emacs from Jethro Kuan

------
neonscribe
[https://emacsformacosx.com/](https://emacsformacosx.com/) is a very good port
to MacOS. One advantage of Emacs on MacOS is that the Command key is not part
of the traditional Emacs key bindings. This port uses Option for Meta and
supports most of the usual MacOS Command key shortcuts, so you can use the
familiar MacOS keys as well as the official Emacs key bindings.

~~~
m463
I agree with everything you've said. I used to use Xquarts and xemacs but then
that became available for a quick download.

I will mention cmd-c / cmd-w is still an anomaly. I sometimes capitalize stuff
or close windows.

------
samatman
Everyone has already suggested the Emacs tutorial, and Spacemacs, so I have
two things to add: the Emacs tutorial is borderline-useless if you're using
Spacemacs, and as a vi-proficient user, you should.

Second, I want to recommend the Emacs _Lisp_ tutorial, which I would argue is
the best official tutorial for a programming language, full stop. This will
teach you a tonne about Emacs which you won't pick up any other way, and you
can fill in differences between Spacemacs and vi(m) by the usual expedient of
trolling the internet for clues.

------
kfogel
Single best thing you can do:

Find an expert Emacs user who's willing to help, and have them watch you _in
person_ , even for just a short time, as you use Emacs to do things. Lather,
rinse, repeat. Make sure they show you how to use the built-in help and
feature-exploration mechanisms (but they'll know to do that anyway, if they're
an expert).

~~~
kfogel
(Okay, well, I guess this was a particularly bad time to recommend a
specifically _in-person_ help session :-). Live video would work too, as long
as the resolution is high enough for them to see what you're doing.)

------
pdxpatzer
start with using graphical Emacs on your platform of choice. Avoid using Emacs
through a text terminal, to begin with ...

then start with

Absolute Beginners Guide to Emacs
[http://www.jesshamrick.com/2012/09/10/absolute-beginners-
gui...](http://www.jesshamrick.com/2012/09/10/absolute-beginners-guide-to-
emacs/)

follow up with Emacs' tutorial and online help

follow up with Mike Zamansky videos on YouTube
[https://cestlaz.github.io/stories/emacs/](https://cestlaz.github.io/stories/emacs/)

finally check out the blog entries (and the book !) at
[https://www.masteringemacs.org/](https://www.masteringemacs.org/)

------
vpEfljFL
As you mentioned you're comfortable with vi, Spacemacs probably should be a
good start although I think it kind of overloaded. Doom emacs should be a
better/lighter option to start with till you ready to create your own edition.

I suggest don't go full inside but start slowly incorporating emacs into your
workflow.

If you write code then using emacs only for git via magit for the first couple
of weeks should be a good start (while reading some emacs related book in
parallel).

Then try to experiment with the org mode, this thing alone might get you on
the hook to be productive with the tool.

If you like the experience then I suggest you to consider buying ergonomic
keyboard like ergodox/maltron/kinesis advantage to improve your typing.

~~~
asiachick
If org mode is it then plenty of other editors have org mode

[https://packagecontrol.io/packages/orgmode](https://packagecontrol.io/packages/orgmode)

[https://marketplace.visualstudio.com/items?itemName=tootone....](https://marketplace.visualstudio.com/items?itemName=tootone.org-
mode)

[https://github.com/jceb/vim-orgmode](https://github.com/jceb/vim-orgmode)

~~~
olivierestsage
Although these are great, it's worth noting that they don't even come close to
the functionality offered in Emacs org-mode.

------
akater
I believe it's important to find a community which would offer quality real-
time help. I've seen some, and the really good one was not in English so I
can't recommend it, I guess. Freenode emacs chat is said to be filled with
offtopic; that's not my cup of tea but you might find it useful.

Members of said lovely community thoroughly recommended Mastering Emacs to
newcomers as a number one introductory text which I since do as well—mostly
because they did. I also recommend built-in tutorial.

As for packages,

• helm or some other fuzzy completion thing; make sure your M-x, C-h f, C-h v
do offer fuzzy completion, it improves discoverability greatly. Recent (27?)
Emacsen may have something like this out of the box.

• avy: jump to positions on screen

• there are several packages that offer insert/command mode including the
famous evil-mode but it's a good idea to get used to defaults. “Mastering
Emacs” has something on this. I've heard macOS supports default Emacs keys
_everywhere_ (not true for other systems)

• which-key can display keys and commands available at the moment, quite
helpful from the start. You can actually find some of this information with
context menu but it is less convenient. The issue with which-key is, you need
to configure it to actually see its stuff. A config for it may be found in the
link below

•
[https://github.com/a13/emacs.d/blob/master/README.org](https://github.com/a13/emacs.d/blob/master/README.org)
is a cleanly written init file; if you want a starter config for package x,
try searching there for (use-package x ..) expression, copy it to your init
file, press C-M-x and it's applied (note: it will often download the package,
too). Many popular packages and built-in features are covered. Tweak some
parameters, C-M-x, observe the changes immediately.

• last but not least, to make use of many existing configurations out there,
you will need use-package. So install it early and learn to load it on startup
(see the very config above as a reference)

------
loosetypes
Emacs is weird. I’ve been using it for a few years and am definitely far from
an expert.

Emacs led me to elisp which led me to Common Lisp which led me to scheme which
led me to racket, each of which has its own unique set of literature.

I’m enjoying the journey. It’s a refreshing change of pace from the ever-
changing, cutting-edge, hyped-up programming world many of us live and work
in.

Emacs has also led me to further interest in macros, compilers, and
programming languages.

If you don’t have prior experience with lisps I’d recommend Gentle
Introduction to Common Lisp, How to Design Programs, or Practical Common Lisp.
The fundamentals from each apply well to elisp.

If you want immediate(ish) productivity, id recommend emacs prelude, doom, or
spacemacs.

------
randomcarbloke
You cannot grok it without first trying to live inside it.

It can be treated as an editor, and as your workflow slowly adjusts you will
find yourself writing a mental wishlist.

Realising that wishlist is where Emacs shines among other
editors/IDEs/applications.

It is a headspace/workspace and imo the programming equivalent of BASB.

I for example use it because I want nothing to pull me from my workflow, so I
have shells, repls, notebooks, filesystem browser, internet browser, rss, and
a slew of other utilities tiled, something akin to a Bloomberg terminal, even
spotify if I need music. It has enabled my productivity in a way no other
application could.

~~~
jalopy
>shells, repls, notebooks, filesystem browser, internet browser, rss, and a
slew of other utilities tiled, something akin to a Bloomberg terminal, even
spotify if I need music

Could you describe each of the specific packages you use to accomplish all
this? I'd love to add more tools.

~~~
randomcarbloke
Certainly: Shell: EShell, Term, (inferior) Shell

Repl (these will depend on what language you're using): usually I just run
this within a shell, dedicated to the task (Mx rename-buffer) but there are
specific shells for this like Python-shell.

Notebook: EIN, can be a pain to set up, requires you to run a notebook server,
best done headlessly of course.

Filesystem browser: Neotree is the best I've found but there are other decent
ones.

Internet browser: EWW is fine, some sites will better in mobile format, some
in simple format if available.

RSS: Elfeed

Spotify: Helm

Have flirted with BitlBee for Discord and WhatsApp but think it is deprecated
for the latter.

Most of the above are available with the default install. Additionally there
are modes and such that make life easier like SLIME, MultipleCursors,
WindowPurpose etc. Some settings will need to be fiddled with to get Elfeed
updating when you want it to, I mean it's never as simple as installing a
package as I'm sure you know, but once up and running it's fantastic.

------
ben509
I'll add one small point towards grokking it: Emacs keybindings aren't just in
Emacs. It really helps to feel fluid in Emacs if you're used to using the
standard navigation all the time, and it's baked in to so many applications it
takes almost no configuration.

All readline apps support[1] them, including bash[2] and many others emulate
them.

On MacOS, support for emacs keybindings is standard in Cocoa text views[3] and
you can improve it quite easily[4].

[1]:
[https://tiswww.case.edu/php/chet/readline/readline.html#SEC1](https://tiswww.case.edu/php/chet/readline/readline.html#SEC1)

[2]:
[https://www.gnu.org/software/bash/manual/html_node/Readline-...](https://www.gnu.org/software/bash/manual/html_node/Readline-
Interaction.html#Readline-Interaction)

[3]:
[https://developer.apple.com/library/archive/documentation/Co...](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/EventOverview/TextDefaultsBindings/TextDefaultsBindings.html)

[4]: [https://github.com/fkchang/emacs-keybindings-in-
osx](https://github.com/fkchang/emacs-keybindings-in-osx)

------
dpbriggs
I've been using Emacs for everything since highschool and through University
and my career. The best way to get used to it is to bootstrap with tutorials
and then just keep using it. I learned a lot about it from doing basic
projects and then homework assignments, and then at work.

I started out by following basic tutorials, like this one [0], and working my
way up. You may want to find a guide to get themes setup, and some rough edges
ironed out.

Alternatively, you could dive into distributions. I highly recommend
Spacemacs, and have written an article about it [1]. It is a lot of learning
especially if you're familiar with vim. The github page is also a great
introduction [2]. I would recommend using the develop branch over master, as
master tends to be very stale.

I have also heard good things about Doom emacs, another vim style distro.

[0] [http://www.jesshamrick.com/2012/09/10/absolute-beginners-
gui...](http://www.jesshamrick.com/2012/09/10/absolute-beginners-guide-to-
emacs/)

[1] [https://dpbriggs.ca/blog/spacemacs-for-fun-and-
profit](https://dpbriggs.ca/blog/spacemacs-for-fun-and-profit)

[2]
[https://github.com/syl20bnr/spacemacs#introduction](https://github.com/syl20bnr/spacemacs#introduction)

~~~
quickpost
I've been trying to read the article you wrote about spacemacs for several
days, but it appears your site is down! Any chance you can fix it? :)

~~~
dpbriggs
Hey my apologies: The site should be back up. If you get a cloudflare error
try reloading a few times.

Otherwise you can read it here on Github:
[https://github.com/dpbriggs/dpbriggs-
blog/blob/master/blog/2...](https://github.com/dpbriggs/dpbriggs-
blog/blob/master/blog/2019-02-14/spacemacs-for-fun-and-profit.org)

------
fishyfriend
Having recently adopted Emacs enthusiastically after years of fairly low-
powered Vim use, this is what has worked for me.

\- Do the built-in tutorial before anything else.

\- Read through most of the manual. It's extraordinarily good despite
containing a few small and usually obvious errors. You can skip things, e.g.
calendaring if you're happy with your current calendar system.

\- Get a friend's nontrivial init file (.emacs, init.el, etc.) or find a
representative one online. Ideally use one from someone who uses Emacs for the
same stuff you will, so more of it will be relevant to you. Read and
understand every part of this file, copying and adapting into your own .emacs
as you feel moved.

\- Use the built-in help system aggressively. Don't be afraid to go on detours
when an intriguing function or variable meets your eye.

\- Spend some time browsing the descriptions of packages in the `list-
packages' buffer to find interesting packages, and read their source code.

\- Read the Intro to Elisp (note: I think I used a 3rd party alternative
tutorial somewhere, not sure which one) and use the Elisp manual more as a
reference. Take as much time as necessary to digest anything that seems
confusing. A few things aren't super intuitive on first read, for example the
precedence relationship among various keymaps. Make diagrams!

\- Contribute some bugfixes and new features to packages you are using. Start
small.

\- Use the Emacs Wiki as a secondary resource.

------
maryrosecook
I had a different experience to kabdib: customization made me able to actually
use emacs productively.

I joined a company where most of the devs used emacs, so I kind of needed to
adopt it too. I started with very little config and it was very hard. Because
many operations were different to the GUI editors I'd used before, I had to
waste 20% of my brain power to consciously do things that should be
unconscious (save, cut, paste etc). This made it much harder to program!

The first step was updating the config to make emacs more similar to my old
editor. For example: make it so pasting text when text is selected replaces
the selection. Turn off branching undo. Install a plugin that gave me an
autocomplete list of every file in my current project. Make it so that if I
copy text in emacs, it appears on the OS-wide clipboard. I'm sure your list of
things will be different.

Another important step was getting my emacs theme to look nice. This really
made me love the program a lot more. It's silly, but there we are.

The third important step was finding things that emacs does better than other
editors. For me, a big one was having a terminal inside my editor (lots of
editors do this now, but back then it was rare).

Hope you end up loving emacs!

------
qorrect
[http://emacsrocks.com](http://emacsrocks.com) is a great introduction.

~~~
japhyr
Yes! And it's so much fun to watch. Those are my go-to videos when testing
audiovisual setups. Every time I hear his voice I want to get more efficient
with emacs.

------
ludwigvan
1- Understand that it is a programming environment, composed of functions,
commands and variables; and all of these are documented, which you can get via
`C-h f`, `C-h v`.

2- Any key combination you touch translates to those commands, so `C-h k`
which shows you the actual command is key. Learn the commands behind the keys
and mix and match to suit your style. Read [http://steve-
yegge.blogspot.com/2007/02/my-save-excursion.ht...](http://steve-
yegge.blogspot.com/2007/02/my-save-excursion.html) to get the overall idea.
Use smex or helm's helm-M-x to be able to call the commands without
remembering their names fully. You can also use apropos to search for
commands, but smex or helm is much easier. This way, you don't need to learn
that many shortcut keys.

3- Define a shortcut key to open your .emacs file so you can define new
commands without extra effort. Keep it to a single file in .emacs.d dir to
make things easier. Too many files make things harder to maintain for me.

4- Practice on your elisp skills on `ielm`.

------
base698
If you know VI I'd recommend Evil Mode: [https://github.com/emacs-
evil/evil](https://github.com/emacs-evil/evil)

Helm is pretty amazing and almost worth the cost of Emacs by itself:
[https://emacs-helm.github.io/helm/](https://emacs-helm.github.io/helm/)

------
mullikine
The easiest start-kit I found to be spacemacs. discover plugins through
tapping around which-key.

I've been using emacs for about a year now. My config is stable at 1506 emacs
packages. It runs on 6 different emacs distributions. Some would say my setup
is bloated. With a 2 minute startup time, I need emacsclient. It's important
to remove any impediments to learning as possible. Any weird keyboard
problems, or waiting times you should try to eliminate. It takes an obsessive
kind of discipline, like using batons on homeless people to combat the spread
of coronavirus.

Every day I check the emacs reddit and search melpa for packages with
particular keywords in their names. Every time I hit a bug I try to solve it.

Run multiple emacs instances so if you break something, at least one emacs
still works. I recommend using 'lispy' for emacs lisp, but until you have
learned that I recommend using vim for writing elisp. You kinda have to make
key bindings to learn new emacs packages.

------
yoloClin
Mike Zamansky has a pretty decent series which focuses mostly on third party
package features -
[https://www.youtube.com/watch?v=49kBWM3RQQ8&list=PL9KxKa8NpF...](https://www.youtube.com/watch?v=49kBWM3RQQ8&list=PL9KxKa8NpFxIcNQa9js7dQQIHc81b0-Xg)

------
asiachick
I'll probably be the nay sayer around here but I don't find emacs all that
special. I've used for maybe 18 months at various points in my life, entire
projects in emacs. Maybe I don't know what I'm missing. I've written
extensions in elisp. Used keyboard macros. Split windows, etc. etc. etc. What
am I missing? Those features exist in every editor I've used since about 1988.
They're all scriptable and customizable, at least the ones I've used.

Please name some features that I'm missing.

People talk about adding their own tweaks. Any programmable editor lets you
add your own tweaks. I've added my own to several. Including emacs. Emacs
wasn't special here

I'm happy to use emacs when I have to (it's the only thing installed). But
otherwise not feeling it.

~~~
plafl
I will talk about features I do use. My emacs is not very customized for that
matter, some keybindings for moving frames and buffers and a few packages:

I have not seen something similar to undo-tree in other editors:
[https://www.emacswiki.org/emacs/UndoTree](https://www.emacswiki.org/emacs/UndoTree)

I sometimes keep different frames for different machines through ssh (TRAMP),
and rename the frames. I'm not sure how good is multi-window support in other
editors or remote editing of files for that matter.

------
japhyr
Does anyone have any recommendations for configuring emacs so it's easy to use
with a standard MacBook keyboard and a full external keyboard?

I used emacs for a couple years on a linux laptop with a full keyboard, and I
loved it. Then I got into more teaching than programming, so I moved to some
beginner-friendly editors; I wanted to use the same tools I was recommending
for my students.

Now I'm doing more dev work again, and I really miss emacs. But I'm a little
lost about how to map keys so I can jump between my laptop in standalone mode,
my laptop when I have an external keyboard connected, and non-mac linux
machines.

~~~
alexjm
One thing I do on a laptop keyboard is remap Caps Lock to Control to make that
easier to type. It's in System Preferences > Keyboard > Modifier Keys.

On an external keyboard, I don't remap because I have a Control key in both
corners of the keyboard that I can press with the corner of my palm/the base
of my pinky finger.

BTW, did you know many Emacs keys work in standard macOS text views? For an
intro and a bunch of details, see
<[http://www.hcs.harvard.edu/~jrus/site/cocoa-
text.html>](http://www.hcs.harvard.edu/~jrus/site/cocoa-text.html>) and
<[http://www.hcs.harvard.edu/~jrus/site/system-
bindings.html>](http://www.hcs.harvard.edu/~jrus/site/system-bindings.html>).

------
catern
Do the tutorial (C-h t), and then read the manual (C-h r).

------
imgabe
It's far from a comprehensive resource, but the thing that got me started with
emacs many years ago was Steve Yegge's post Effective Emacs:

[https://sites.google.com/site/steveyegge2/effective-
emacs](https://sites.google.com/site/steveyegge2/effective-emacs)

Note some of the advice, such as how to swap Ctrl and Caps-Lock on specific
OSes, maybe be outdated now.

That and the built in tutorial - there should be a link on the screen when you
start up emacs, or `C-h t` - should be enough to get you started.

------
Koshkin
[https://duckduckgo.com/?t=ffsb&q=learn+emacs&ia=web](https://duckduckgo.com/?t=ffsb&q=learn+emacs&ia=web)

Pretty good resources right at the top.

~~~
AnonC
Thank you for pointing that out. I should’ve checked that out first, but I
thought the collective mind here may be a lot more helpful (so far all the
comments here have been very helpful to me, including yours).

------
bogomipz
You could have a look at "Harley Hahn's Emacs Field Guide" This book came out
a few years ago. I liked it. It's one of the few books I think I have seen on
Emacs. There are previews available for the chapters as well here:

[https://www.apress.com/gp/book/9781484217023](https://www.apress.com/gp/book/9781484217023)

------
viburnum
I found a two page cheat sheet in 1993 and that was enough for the next 27
years.

------
noelwelsh
Let me add to the recommendations to try Doom. I've written up some notes on
workflows in Doom: [https://noelwelsh.com/posts/2019-01-10-doom-
emacs.html](https://noelwelsh.com/posts/2019-01-10-doom-emacs.html)

I didn't find anything similar when I got started using it, so it might be
useful to you.

------
Torwald
I've found the Emacs Wiki always solidly maintained:
[https://www.emacswiki.org/emacs/SiteMap](https://www.emacswiki.org/emacs/SiteMap)

S. Chua's blog is the best "zine" I think:
[https://sachachua.com/blog/](https://sachachua.com/blog/)

To avoid "but vi/vim and the shell…" which is a sort of "mental flu" every
Emacser has to go through at least once in his life, understand this:

"the UI paradigm of Emacs" is also called a roguelike interface by ESR, vi's
too: "In Chapter 11 we described the effect of the absence of standard arrow
keys on early roguelike programs; vi was one of these. "
[http://www.catb.org/esr/writings/taoup/html/ch13s03.html](http://www.catb.org/esr/writings/taoup/html/ch13s03.html)

------
gtpedrosa
I have started using emacs in 2016 because of org-mode. It was powerful enough
to make me use emacs on a daily basis since them. However, I have been using
RStudio/Sublime as IDE/editor, not emacs.

Curiously last weekend I have found a video about org-roam and the presenter
mentioned he was using Doom emacs. I was curious enough to try it. It uses vim
key bindings by default. To get started I highly recommend this series by
Zaiste [0], he explains how to set up the environment and digs into org-mode
which were my main concerns. I found the sections on projectile, magit, dired
and avy very helpful. Now I am tempted to give it a try in one of my projects.
The downfall so far is I didnt find an in depth explanation on how to grok it
with python.

[0][https://www.youtube.com/watch?v=rCMh7srOqvw&list=PLhXZp00uXB...](https://www.youtube.com/watch?v=rCMh7srOqvw&list=PLhXZp00uXBk4np17N39WvB80zgxlZfVwj)

------
praptak
Emergency Elisp by Steve Yegge - best intro to get started with elisp.

~~~
celeritascelery
[https://steve-yegge.blogspot.com/2008/01/emergency-
elisp.htm...](https://steve-yegge.blogspot.com/2008/01/emergency-
elisp.html?m=1)

------
weaksauce
personally i'd use something like spacemacs. it combines the power of vim with
the power of emacs. it's not perfect and you should use the develop branch of
it because the master one is woefully out of date. the idea of spacemacs is
that they have layers that you can enable or disable that seek to customize
the defaults of emacs to 1. work well with vim in all modes, 2. collect and
configure sane defaults for packages packages(akin to vim plugins) relevant to
the feature. some say to use emacs with a blank canvas and to learn it from
scratch but, frankly, the emacs defaults are absolute rubbish. it's a good way
to get a reasonable emacs out of the gate and you can always cut the cord if
you really want to later.

magit is a fantastic git UI. helm is a great ui for searching lists of
things(used very often)

------
beshrkayali
Learning GNU Emacs, 3rd Edition
[http://shop.oreilly.com/product/9780596006488.do](http://shop.oreilly.com/product/9780596006488.do)

I've been using Emacs for ~5 years now, and I switched from Sublime Text. I
used Vim here and there but I wasn't a huge fan, and I always heard that Emacs
is _the editor_ that can solve anything. Org mode is what got me really
interested so I read through that book and switched to Emacs fully after a
couple of weeks of light usage and reading.

Now I only use Emacs, and I've never been happier programming. It's truly a
remarkable piece of software.

Edit: just want to say that you should use vanilla emacs and try not to
install any plugins at first. Resist the temptation to go willy-nilly on some
awesome-xyz list.

------
zeppelin101
I would honestly just start out with either Spacemacs or Doom Emacs. There is
a lot of information on these 'distributions' and many YouTube videos, as
well. These 'distros' will allow you to quickly get a feel for the power of
Emacs, because they contain sane defaults that will enable you to get a quick
feel of what Emacs is capable of. After doing this, you might decide to scrap
them and start with a default Emacs installation that you slowly build up. But
that is a huge investment of time and you should at least try these popular
alternatives before you go into the crazy time sink of 'rolling your own'
system. I realize that many purists might take issue with this suggestion, but
it's what worked for me.

------
nvarsj
It's a great time to get into Emacs. The community is growing because of great
projects like Spacemacs and Doom Emacs which let you get a fully working
environment up very quickly, with good defaults.

I personally would recommend doom-emacs ([https://github.com/hlissner/doom-
emacs](https://github.com/hlissner/doom-emacs)) which has an easy to
understand codebase.

Now as you use it, you'll inevitably run into bumps or things you want to
change. This is where you start to learn. In doom you can just press `SPC h a`
to search up anything you could want (`SPC h` will show you all possible help
options). Discoverability in Emacs is amazing, and puts all other editors to
shame.

------
rashkov
Highly recommend spacemacs. Solid documentation, fantastic evil-mode
integration, well organized key bindings and a config file that makes sense.

If you like trying new programming languages then all you do is add it to the
layers list, and it’ll install recommended packages for that language. It’s
nice to have that ready for you to use so you don’t waste time researching
which packages go with which language. Then you just hit “space-M” and you see
everything you need to work with that language. Read the README.md for that
layer or even dive into its code if you want to know how it works.

I don’t think I could have moved from Vim to emacs without spacemacs and will
be forever grateful for that.

------
noufalibrahim
I mentor fresh graduates and help them find jobs as part of my work at
[https://thelycaeum.in](https://thelycaeum.in) \- We introduce people to Emacs
and I use a bunch of videos which I made for another side project to help them
learn it and these might be useful for you. They're available at
[http://emacsmovies.org/blog/where_to_begin/](http://emacsmovies.org/blog/where_to_begin/)
\- I specifically avoid starter kits and other such stuff and focus on
teaching how to get comfortable with basic ideas of the editor. Good luck and
welcome. :)

------
kwoff
In the mid-90s I started using emacs just because a classmate mentioned it
(previously we'd used whatever was on VMS; I think this was around when I
discovered Unix). A few years later in grad school, I was in the computer lab
one evening and the sysadmin came in, sat down beside me and showed me how to
really use emacs, and I was enlightened. ;) No, but seriously, I don't really
remember what he even showed me (though I think one thing was dired), but
having a guru give you a few tips is, at least in my experience, a great way
to at least open your mind to learning more.

------
vhodges
The tutorial and M-x apropos is how I learned so many (many) moons ago.

------
agentultra
[https://emacsforosx.com/](https://emacsforosx.com/)

[https://prelude.emacsredux.com/en/latest/](https://prelude.emacsredux.com/en/latest/)

[http://emacsrocks.com/](http://emacsrocks.com/)

[https://sachachua.com/blog/category/emacs-
news/](https://sachachua.com/blog/category/emacs-news/)

------
lunias
I'd start w/ Vanilla Emacs and then look at Doom Emacs. I recently switched
away from Spacemacs (kinda slow IMO).

[https://ethanaa.com/blog/switching-to-doom-
emacs/](https://ethanaa.com/blog/switching-to-doom-emacs/)

I wouldn't worry too much about elisp until you're at least intermediate. I've
used Emacs for 10+ years and I next to no custom config that I've found
indispensable.

------
cbsmith
A lot of good advice here. I'll just say two things: use the built in
tutorial. It's actually pretty good, and the built in help can get you going
from there.

Also, not as a tutorial, but more as a reference,
[https://emacswiki.org/](https://emacswiki.org/) is a great site for not just
information on the editor itself, but all the various modules/hacks people
have contributed.

------
willberman
I’d give the same advice I’d give to understand anything remotely complicated.

Pick a real goal you want to accomplish that the thing you want to understand
is a good fit for.

Maintain a curious mindset while trying to accomplish the goal.

To frame this in the context of emacs. Just start using it for programming.
When you come across something you want it to do, google how do I make emacs
<...>.

I know it sounds overly simplistic, but just trust me and try it.

------
bekantan
If you are comfortable with vi (like I am), you will definitely like Doom
Emacs. I started using it recently for org(-roam) and I really like the
experience.

I installed Emacs from brew and apt (on two machines) and just ran doom
installation script which you can find in Doom's GitHub repo.

To find your way around you can just follow command descriptions when you
press <SPC>.

------
sfrzxyz
Shamelessly pluggin my little project here: Learn Emacs the ADHD way:
[https://github.com/gsforza/emacs-the-adhd-
way](https://github.com/gsforza/emacs-the-adhd-way)

It is mostly about learning Emacs without blindly copying configs from GitHub
and getting distracted by all the shiny packages one can get.

------
aladine
I believe you already found many useful links in this page. If you have reddit
account, possibly you can check out "Weekly tips/trick/etc/ thread" in
[https://www.reddit.com/r/emacs/](https://www.reddit.com/r/emacs/) and get
inspired every week.

------
synthc
[http://emacsrocks.com/](http://emacsrocks.com/) is a series of videos
demonstrating various emacs modes and extensions.

The multiple cursors episode is really cool:
[http://emacsrocks.com/e13.html](http://emacsrocks.com/e13.html)

------
donaldihunter
[http://emacsrocks.com/](http://emacsrocks.com/)

[https://emacs.sexy/](https://emacs.sexy/)

[https://github.com/emacs-tw/awesome-emacs](https://github.com/emacs-
tw/awesome-emacs)

------
Myrmornis
My answer is to embrace the challenge of learning Emacs Lisp and using it.
Personally I think Emacs makes most sense for those who think learning and
using some elisp sounds fun/interesting. What I’m not sure about is what to
recommend for learning it. I remember finding it non-obvious how to learn it.

~~~
frank2
Once you understand basic Lisp, (e.g., have worked the first half of the
Little Lisper or the Little Schemer or the first few chapters of Structure and
Interpretation of Computer Programs) the official Emacs Lisp manual [1], M-x
describe-function and (progn (info "elisp") (Info-index topic)) are all you
need. At least that has been my experience.

My favorite thing about writing Emacs Lisp code is that it is easy (e.g., just
an 'apt get' on Debian) to install the aforementioned manual locally -- and
the other resources I mentioned a part of the basic Emacs install -- and once
I have installed that manual, I don't need internet connectivity when I am
writing Emacs Lisp code. (Not having internet connectivity means I waste less
time browsing around aimlessly.)

[1]:
[https://www.gnu.org/software/emacs/manual/elisp.html](https://www.gnu.org/software/emacs/manual/elisp.html)

------
dhosek
I like Aquamacs on the Mac. It comes with the most popular packages pre-
installed in it and enables a lot of basic customization through the GUI. Even
though I do the vast majority of my code editing in IntelliJ, it seems I end
up installing Aquamacs on any new machine within a couple of weeks.

------
mathnmusic
I have been collecting learning resources about Emacs here:
[https://learnawesome.org/topics/a7a55488-8320-4d88-8f2b-4afa...](https://learnawesome.org/topics/a7a55488-8320-4d88-8f2b-4afa9c767ac6-software-
tools-emacs)

Feel free to add more.

------
threatofrain
What’s the most common IDE and tooling setup for Clojure folks?

~~~
fulafel
From the latest Clojure survey it seems CIDER and Cursive are pretty close,
Calva is gaining in the 3rd place and vi has a steady following at #4.

([https://clojure.org/news/2020/02/20/state-of-
clojure-2020](https://clojure.org/news/2020/02/20/state-of-clojure-2020))

------
linsomniac
Since you know vi, maybe try Spacemacs? As a serious vi user, who has at times
wanted to try emacs, I thought Spacemacs would probably be the way to get
there from here.

------
fmozturk
[https://www.youtube.com/results?search_query=%23emacs](https://www.youtube.com/results?search_query=%23emacs)

------
yewenjie
Spacemacs has been mentioned multiple times here. I just wanted to recommend
using the develop branch of it which is pretty stable and far ahead of master.

------
allarm
Start using org-mode and learn as you go. It will help you to keep interest -
org-mode is full of amazing features.

------
petr_tik
I am keen to crowdsource a study of emacs workflow practices, where we can
collect, compare and analyse different development practices among emacs
users. This should help other emacs users to borrow modes/keybindings/specific
techniques/tricks.

 __* Motivation

This is inspired by an ongoing conversation about emacs with a friend and a
debugging interview that I really enjoyed.

 __* Exchanging emacs tips with a friend

A friend of mine is pretty proficient in emacs: org-mode all the things,
written >500 LoC of elisp, tried several distributions. We still regularly
teach each other about existing emacs functionality and exchange messages
along the lines of: \- I just found that there is a function foo, which I have
made a keybinding foo and can now search open a tab with a SO search with text
from the clipboard \- whaaat? That's super useful! \- I know, right?

He works with a couple of greybeards, who also seem to be constantly finding
emacs functionality that makes their lives easier, which suggests it would be
beneficial for all of us to watch others in emacs.

 __* Interview

I was given a real git repo that I needed to load into my environment
(spacemacs on Linux) to debug and fix failing tests. They sat me down during
the onsite (the days when we would go to interview in person), told me to
download the repo from the URL, told me how to run the tests (after activating
the python venv) and watched me debug and fix failing tests - only 5 were
failing from about 100. The interviewers were not proficient in emacs, but I
felt that they could follow my thought process and workflow. I had only
recently set up python dap-mode and felt clunky navigating in pdb through dap,
so ended up print debugging.

It made me think how interesting it would be to watch other people with
different backgrounds and experiences debug the same problem and how often I
would learn new tricks or debugging techniques. Having a good understanding of
the problem and the code allows you to focus on the activity of programming
and watch out for new ways of tackling the same problem.

 __* What will we investigate

Furthermore, it might be interesting to see what debugging practices are
statistically more succesful in tracking down the bug faster (and control them
for overall years of programming experience and emacs proficiency).

If our sample is big enough we can answer questions like: Correlation between
overall years of programming experience and debugging time? Who is faster at
debugging: printf or gdb debugger people? Which keybindings and modes are most
frequent across users? Is there a correlation between having custom elisp
functions and debugging time?

 __* Format

I will prepare a representative repo in the most popular language (I am most
comfortable in Python, happy to consider other languages, if people prefer),
bury some bugs in it (that will be easy), administer the study and summarise
the findings in a spreadsheet/write-up.

Following the debugging session outlined above. Every participant:

starts recording their screen

Starts a fresh emacs instance with their config and loads a emacs lisp script
that we provide for printing keypresses and recording keypresses + function
calls to a log file.

download the prepared repo

run tests

investigate failing tests

fix them

commit their changes

The participant ends the screen recording session before sending me

    
    
       - the video to me or youtube/dailymotion URL 
       - plaintext keylog history
       - <optional> link to their elisp config
    

I appreciate logging keypresses/function calls might feel intrusive, so if you
are uncomfortable doing that - don't! At the same time, if we want to share
good debugging practices and general emacs tricks - I see this as the most
impactful way to share techniques and elisp snippets.

I watch it, sumarise the findings and present a write-up.

Who is interested?

~~~
AnonC
OP here, so I’m completely useless for this. It sounds wonderful. Whenever you
get this done, please do a Show HN or Tell HN on this.

~~~
petr_tik
hey, it will be interesting to see how you would tackle the problem as well to
compare emacs novices to proficient users.

------
znpy
follow the tutorial! it will guide you through the learning :)

------
throwaway_pdp09
Not core functionality, but worth knowing:

    
    
      M-x tetris

------
holri
Emacs has a great interactive live tutorial integrated.

------
kalium-xyz
emacs comes packaged with all the tools needed to debug and learn emacs c:

------
klibertp
Lots of great advice here already, and I'm probably too late for anyone to
read this anyway, but I have a few things I'd like to mention.

First, I firmly believe that kabdib comment - that you shouldn't customize
Emacs, or fiddle with it too much - is not good advice for the year 2020.
Forty years ago (i.e., when kabdib started using it), I would have agreed with
it (I'd have to be born first, though). In essence, the vanilla Emacs is a
powerful text editor with macros, syntax highlighting for many languages,
debugger and linter integration, split panes, great diff viewer, and so on. In
short: vanilla Emacs is still loaded with features, especially if you compare
it to EDIT under MS-DOS or MS Write from Win 3.1.

The problem here is twofold: due to strict GPL licensing requirements, the
inclusion of new features in the Emacs core is not that fast, and (more
importantly) the rest of the world hasn't been frozen for the last 30 years.
What I mean is that today, the comparison is not Emacs vs. Notepad, but rather
Emacs vs. (Sublime | VS Code | Atom | ...). The vanilla Emacs has _literally
no features_ you could see as an advantage over the other editors (and that's
even before we start talking about modern IDEs).

Basically, the only thing Emacs has in its favor is this: it's a full-blown,
incredibly efficient IDE for programming in Elisp, and it's been like this for
the last 40 years. Thousands of programmers used that environment to build the
tools for just about anything under the heavens, and most of their code is out
there, on Emacs Wiki, in ELPA / MELPA repos, and all over GitHub.

To me, using Emacs without taking advantage of its ecosystem is simply a waste
of time. So to summarize this point: you don't have to fiddle with your Emacs
config too much, but one of the first commands you should learn is probably
`M-x list-packages.`

\---

Second, while I say you "don't have to," it's important to remember that you
_can_ fiddle with the config. The "incredibly efficient Elisp IDE" is always
there for you, a single command away. You can use it to read the code and docs
for any function or command you use (or want to). You can make a small change
in command and have it immediately reloaded. You can _put a breakpoint_
anywhere in any function and _step through_ its execution while having call
stack with all the (if not compiled away) variables and their values.

The browser-based editors could, in principle, offer a similar or better
experience, but for some reason, they currently don't (yet). You don't
necessarily have to use it right off the bat - or you can ignore it altogether
- but when you need it, it's always there. Fixing a typo, disabling unused
features, automating chains of commands, binding commands to whatever is
convenient to you, and so on - Emacs allows you to do all of that more
efficiently than any other editor I've seen (LightTable being dead and all).

Also, as for "endlessly tweaking" your config: in my experience, that's not
what happens. It took me a year to learn Elisp, then I spent about two years
trying out various packages, writing my own, adding some conveniences on top
of what's provided, and so on. That was almost a decade ago, though, and since
then, I touched my config with very minor edits every couple of months, and I
tried out some new packages as they came, so maybe a few times a year?
Something like that. This is because I made my Emacs fit my habits, and once I
did, I have had no incentive to fiddle with it further. Why would I? It works
exactly the way I want it to.

\---

TLDR: first, learn how to install (and _uninstall_!) packages and how to
customize them with the `customize-...` commands. Then, go through the
"awesome emacs" on GitHub and play with any package that catches your
attention. Ask for package recommendations on StackExchange or somewhere if
you're not sure which to choose or if there's a package implementing what you
want (there is). Then, if you wish, delve deeper: start debugging and editing
the packages' code, learn Elisp in the process, write whatever helpers you
need. And after that, yes, simply _use_ the editor ( _your_ editor!) for the
next couple of decades.

