
Why GNU Emacs? - rekado
http://elephly.net/posts/2016-02-14-ilovefs-emacs.html
======
infodroid
Many Emacs advocates fall for the trap of apologizing for why Emacs is not
Unixy, as though it were some sort of defect. They should celebrate the fact
that Emacs doesn't come from the Unix tradition of small, composable tools and
"doing only one thing and doing it well". It is rooted in the ambitious work
of the MIT Artificial Intelligence lab, the LISP programming language, and the
single user MIT Lisp Machine that essentially booted up to a LISP REPL.

~~~
gkya
Unix has a big flaw: through the pipes pass random data. It's up to the
receivers to interpret it. Lisp gives you the possibility to easily structure
your data and pass it around, plus the ability to pass programs around. Other
than this, the unix way and the lisp way are nearly parallel, though in lisp
"command line utility" is called a "procedure".

~~~
liotier
So, JSON passed between a bunch of Javascript things from Github means that
the browser is the new EMACS ?

~~~
jarcane
The article more or less makes this precise comparison.

"Do everything in Emacs" isn't really so different from "Do everything in the
browser."

Arguably, modern browsers are more heavyweight and complex at that. They
certainly eat a hell of a lot more RAM than my Emacs ever does.

~~~
mundanevoice
True, But they also do much more things than Emacs does.

~~~
tempodox
If you really believe that you haven't understood emacs at all.

~~~
jarcane
Ironically, the only thing Emacs can't seem to do these days is be a browser.
;)

~~~
clocksld
The xwidget_mvp branch has been merged into the emacs master branch about a
month ago.

It allows you to embed GTK widgets INSIDE an emacs buffer, effectively
allowing one to create actual GUIs inside of emacs.

This also allows you to embed a full webkit-based browser (with javascript
support!) right into emacs, and use it like a regular browser.

Just clone the emacs repo, build it with gtk3 and xwidget support, and run
'M-x xwidget-webkit-browse-url' to get a full-fledged browser with proper
rendering right inside emacs.

[https://www.emacswiki.org/pics/static/EmacsXembedScreenshot....](https://www.emacswiki.org/pics/static/EmacsXembedScreenshot.png)

~~~
nwah1
There's only one question that remains to be answered. Why?

~~~
gkya
Browsing through an environment that's integrated nicely, deeply configurable,
and completely programmable. What else would you want as a programmer and an
pc user?

------
bjackman
I enjoyed this; I moved from Vim to Emacs a couple of years ago and indeed the
most important thing to recognise is this:

Emacs _does_ have a great text editor, and it's Vim!

With evil-mode you can use all the Vim bindings you're used to (including sed
commands with ':'), but with the added benefits (and drawbacks) of Emacs!

I've also found that fiddling with my .emacs is really fun, fiddling with
.vimrc was usually quite frustrating.

~~~
dorfsmay
I tried this, but found that the issue is that most major modes use a
"grammar" that make sense to native-emacs user, and ended up fighting with
them.

~~~
massysett
After a day of editing on Emacs on a MacBook Pro, my hands felt like they were
going to shrink and stick into a contorted state.

So I tried Evil which does work fairly well for editing text. In some ways
it's better than Vim--the :substitute is really nice as it shows all pending
substitutions in the buffer. But as you said, some major modes work with Evil
and others don't, so I'm never sure what I'm going to get.

Ironically a modern laptop is well-suited for Vim, as vi worked on primitive
terminals--laptop keyboards don't have a lot of keys and they are poorly
positioned. The MIT lab for Emacs probably had nice keyboards.

So these days I am back to Vim and have been finding plugins to make up for
the things that Emacs has that Vim doesn't. vim-dispatch is a decent
replacement for M-x compile.

~~~
unimpressive
>The MIT lab for Emacs probably had nice keyboards.

Oh you have no idea...

[https://en.wikipedia.org/wiki/Space_cadet_keyboard](https://en.wikipedia.org/wiki/Space_cadet_keyboard)

~~~
edoloughlin
It was so ahead of its time, it even had Like and Dislike keys on the RHS!

~~~
aldanor
The LIKE key... priceless :)

------
jake-low
Once, I used Emacs. All I did with it was play in the land of elisp. I never
got any real work done.

Then, a passionate friend converted me to Vim. I only ever used it to do
battle with my .vimrc. I never got any real work done.

Now, I use Atom. Click a button, install a feature. No more distractions.

I wish it were faster though; I can never get any real work done.

~~~
taeric
This doesn't make sense. You used to be someone easily distracted by yak
shaving, is what it reads like.

Installing features in Emacs is not exactly tough, either. I do think you can
get distracted by the sea of things you can install. Probably no different
from the new toys in the realm.

~~~
spion
Makes sense to me. I love both emacs and vim, but I agree there are too many
yaks to be shaved to get them in a usable state.

~~~
taeric
I question the lack of shaving in the next application. Seems there is always
something that could have been done a different way.

------
losvedir
> _Sometimes people who use computers ask me why I would use something as
> “bloated” as Emacs for text editing. Usually they remark that Emacs is a
> hold-over from a by-gone era, much too large compared to editors like “vi”,
> and that they are quite content using a variant of vi or some Notepad-like
> editor._

This feels like a very out of date sentiment to me. I know a decade ago this
was the perception, and well know the "good operating system, bad text editor"
joke you'd see on Slashdot or whatever.

But nowadays while Emacs clocks in at a dozen MB, it's still smaller than what
I'd consider "light weight" editors like ST3 and Atom, and minuscule compared
to the likes of IntelliJ, Eclipse, or XCode.

~~~
lottin
I guess bloated means compared to 'instant startup'. Vi starts always
instantaneously, whereas Emacs can have a noticeable delay, even if it's only
a fraction of a second. Hence the perception that is bloated. Of course
compared to the others you mention is quite fast.

~~~
gkya
Running emacs like "$ emacs <text-file>" is like booting a computer, editing a
single text file, and then "$ shutdown -h now".

~~~
lispm
Not really. GNU Emacs is no operating system. It has no network stack, no
framebuffer interface, no file system implementation, etc. It provides
interfaces to those. As such it does not initialize hardware and it starts no
OS during startup.

GNU Emacs starts a Lisp environment, loads a memory dump, runs various
initialization code, etc.

~~~
gkya
Oh, thankfully someone told me that emacs does not have framebuffers and
filesystems. It doesn't have wireless drivers too!

My grandparent comment was an analogy, for illustrating how it's not the
optimal way to use emacs, as a command line program invoked to operate on one
file and then closed and reopened.

~~~
lispm
The analogy wasn't that great. Booting a machine has nothing to do with
typical uses of Emacs. There are many applications which are long running and
are working on multiple documents - it's just another mode of working with an
application.

One can use GNU Emacs just fine as an editor which starts and quits on a
single file. 'emacs -q' starts in a few milliseconds on my Mac. I use single
file edits with Emacs on the terminal all the time. Though I usually also have
a long running instance of Emacs - but then it is used as a Common Lisp IDE,
not just as an editor.

Then one can setup an Emacs editor server.

Or start the Editor and leave it running. This is no different from, say, a
CAD program or any typical application on the Mac, where usually a single
instance of an application keeps running, editing multiple documents.

------
sprash
If you are a newcomer and look at Emacs what you see at first glance on the
outside is basically total crap. The default behavior of Emacs distinguishes
itself by the complete lack of sanity. Emacs key-bindings are neither
ergonomic nor do they make any sense in any way. They are barely consistent
across modes, only if you are lucky. They are the way they are because they
are old. And old people don't like change. However my experience was, the more
I learned the more crap appeared. One layer of crap after the other. At first
everything could somehow be fixed with a lot of configuration and scripts. I
needed several hundred lines of Lisp code in my init.el just to be able to
work normally.

But then the lowest emacs layer of crap appears which can not be fixed. It
includes issues like lack of multithreading, elisp being the least capable and
at the same time by far slowest lisp dialect. Stuff like the lack of ability
to move the cursor off screen. Inherent jumpiness while scrolling which can
not be fixed and really strains my eyes. And don't even try to look at the C
source, it is the worst historically grown ifdef hell you will ever
experience.

And finally there is the community which lacks disposition to unify or work
together. It is more like a community of loners where each of his own produces
personal "modes" which are inconsistent to use and most of the time conflict
which each other. The most important reason for this might be lisp itself. It
is inherently hard to read other peoples lisp code. So everybody writes his
own.

------
tomphoolery
Calling Vim my "editor" is really doing the rest of the programs that actually
make up my development environment a huge disservice. Vim might be what I use
to edit text, but the rest of "Unix" is my IDE of choice. Being able to tab
between an IRC/chat client, my email client, a shell, and an open instance of
Vim is a huge advantage for me. So up until recently, I never had a need for
Emacs...looking at it as too much of an investment into re-building all the
features that are in my shell configuration. That's when I discovered Org
Mode.

I love Org Mode. It's become my primary note-taker, todo list, and general
idea dump. I've used it to plan out projects for work, tours for my band, and
to write down essential things I need to get done each week. Syncing to
MobileOrg over Dropbox, and keeping my Org files in a synced documents folder,
means that all of my computers have access to the same information at all
times. I tried using vim-orgmode for a long time but most of the features that
seemed the most useful to me just weren't supported. Why screw around with
VimL when I could just download Spacemacs, configure Solarized and Monaco to
at least get it looking like Vim, and then use that _just_ for Org Mode?
That's what I've been doing, and I have to say I've fallen in love with how
fast I could get packages up and running and with how many great features
seemed just "built in".

------
hydandata
...Click a button, or invoke a command and an empty, unremarkable rectangle
appears. Little you know that it is a relic from an age long past...

Emacs to me, first and foremost, is a doorway to another dimension, a place
you can escape to from the absolute drudgery of the contemporary software
development.

...A relic, yes, but it seems as alive as ever, a dark block inside it,
blinking, like a pulse on a medical instrument...

It is also a glimpse into what professional tools might be like, if they were
not so obsessed about beginner users. [1]

...You wonder what the hell you should do with it...

[1] I think Erik Naggum kind of nailed it in
[http://www.xach.com/naggum/articles/3065048088243385@naggum....](http://www.xach.com/naggum/articles/3065048088243385@naggum.no.html)

------
e40
What I think is funny is people making fun of me for reading email in Emacs. I
use my own filtering system built on top of MH-E, which is layered on top of
nmh command line tools. MH-E uses GNUS for MIME handling and I'm able to view
HTML messages just fine.

Why I think it's funny: people laugh that I'm using 20-30 year old technology
and new tech would serve me better. To each of them I say: I challenge you to
an efficiency dual/bet. Pit your system against mine. When I show them
actually what I use, they don't take the bet.

Yes, what I'm using was first written almost 30 years ago, but I've tuned the
crap out of it (with my own tweaks) and so have others, improving the tools
themselves.

The only thing that would make my life easier would be if nmh could use IMAP.
There have been many discussions of this, but it's just not a natural fit. I
don't know if it will ever be done.

EDIT: typos

~~~
snaky
People often tend to confuse the newer with the better.

------
flogic
Apparently, I'm feeling ranty today...

<rant>I've used Vi and Emacs as my primary editor. Now I've moved on to
Sublime Text 3. Despite being powerful tools Vi and Emacs have probably harmed
the state of Unix text editing. They've kept antiquated UIs from before
keyboards were an text editing UIs were standardized. It's kinda sad that MS
Dos, Windows and MacOS have all had a plethora of powerful editors with
convenient standard user interface meanwhile the Unix world is anchored to Vi
and Emacs. It seems like they've managed to starve out a good chunk of
innovation on this front.

~~~
kstrauser
I went from Emacs to Sublime and back to Emacs. The UI could be improved,
maybe, but there's a lot to be said for knowing that your editor will still
exist next year. I'm frankly not confident in ST3, but I'm 100% certain that
Emacs will be there.

But beyond that, I find that a lot more stuff Just Works in Emacs. I spend my
days working in Python, and both major Python modes for Emacs are miles ahead
of ST's equivalents. Things like linters work as expected and there are lot
more packages available for niche things. Emacs is subjectively _better_ ,
even if the UI doesn't feel as platform-native as other editors.

I don't use Emacs because I'm a graybeard afraid to learn something new. I use
it because I've tried every new hotness to come along and I've yet to find
something as powerful, well-supported, and ubiquitous.

~~~
oblio
The thing is, in this day and age most people don't need their editor to last
100 years. Because of
[https://en.wikipedia.org/wiki/IBM_Common_User_Access](https://en.wikipedia.org/wiki/IBM_Common_User_Access)
& friends, you can just switch to another editor.

Meanwhile, if you're used to Vi's modal editing or Emacs's elisp, you're
basically going to hate the other tools forever if for whatever reason. For
example if you need IDE features for your project or the Vim/Emacs extensions
for language X are no stable/flexible enough.

~~~
to3m
Once you're past the basic navigation cluster + cut/copy/paste/undo/save
(which tend to be more Windows-style, I'd say, than CUA!) every editor is
different.

Ctrl+F for Find is a common standard, for example, but it's hit or miss
whether this is Ctrl+F for Find (and that's your lot! Find & Replace is
something entirely different), Ctrl+F for Find (and you have a checkbox for
Replace), Ctrl+F for Find (and you have a checkbox for Replace... and this is
how you search across multiple files as well). And there are multiple
standards for all of these additional options. Your muscle memory will be
useless no matter what you're used to. You're welcome to describe emacs as
unusual... but don't assume everything else is a nirvana of UI consistency.
The process of "just" switching can be a bit more inconvenient than you might
think ;)

~~~
criddell
Do you really use one editor for everything?

When I'm working on Python code, I'm in PyCharm. My C++ work on Windows is in
Visual Studio. When I ssh into the Linux machine that serves our in-house
documentation to make changes, I'm using vim. On OSX, I use BBEDit most of the
time. When I'm writing a letter, I'm usually in Word or Google Docs.

I think if I spent all day every day in one environment, I would get bored.

~~~
gcommer
> Do you really use one editor for everything?

Yes, at least whenever possible.

> I think if I spent all day every day in one environment, I would get bored.

The opposite perspective: It's extremely frustrating constantly switching
between significantly different environments with different UIs, different
hotkeys, subtly different jargon, etc.

~~~
criddell
> It's extremely frustrating constantly switching

Maybe that's the difference. I'm not a productive multitasker. When I have
some Python to work on, that's all I'm doing for the next day or two. I'm not
jumping from Word to PyCharm to Vim all day.

------
rl3
Does anyone have an opinion on _Spacemacs_ [0]?

I haven't used it, nor Vim/Emacs. Just came across it during researching the
two. _Spacemacs_ appears to have excellent documentation though.

[0] [http://spacemacs.org/](http://spacemacs.org/)

~~~
Barrin92
I switched from vim to spacemacs a few weeks ago and I don't regret it. The
fact that you can run a shell in a buffer, have on the fly syntax checking and
so on makes coding much more comfortable and you feel like you're using a full
blown ide instead of just a text editor. Would recommend

~~~
arvinsim
Funny that, I also did the same exact thing this month for org-mode. I never
missed Vim.

------
avar
Nowadays the only thing I use outside of Emacs is GNOME Terminal / Google
Chrome / bash / screen / ssh. All the rest (including E-Mail) is inside Emacs.

The Emacs/Vim war is a bit silly, because historically they're really not
comparable in that way (although vim has gotten larger). Emacs is more of an
alternative to GNOME/KDE/Windows/OSX than it is an alternative text editor.

~~~
gkya
"Nowadays the only thing I use outside of Emacs is GNOME Terminal / Google
Chrome / bash / screen / ssh. All the rest (including E-Mail) is inside
Emacs."

There are ansi-term, shell, and eshell. The first is an actual ansi-term
within your emacs, the second is a comint shell, and the third is a shell
implemented in elisp. Emacs has frames, and with C-u M-x shell you can open as
many new shells as you want. proced is like top/ps aux. So it's time to get
rid of gnome terminal and screen :)

~~~
pmoriarty
All of emacs' terminal emulators have been resoundly awful for me. This was
probably my biggest disappointment with emacs. I was so looking forward to
having the shell be useable from inside emacs, but it's really not.

Now I just use a regular terminal with tmux inside it and emacsclient inside
that.

~~~
gkya
Emacs doesn't really have a terminal emulator, and terminal graphics are
mostly unusable in emacs. Shell and ansi-term are there for when you cannot
avoid some shell-fu. I use it mostly for VCS operations that cannot be done
with VC _, and nowadays building Emacs 25 pretests. I use dired instead of ls,
proced instead of h?top|ps, but for a sysadmin these are not viable, I
understand.

_ I do not use magit because I do not only use git, and VC allows me to use
Git, RCS and CVS easily without learning different emacs interfaces for each.

------
jontammeh
Emacs is in one sense the canonical computer program. A "historical landmark"
of computing, the internet, and our industry.

It's grown, it's still viable and used heavily. Even if you don't use it, it's
sort of the Aristotle of computer programs - we owe it a lot.

------
flyrain
I'm a Emacs user and use it everyday. I've seen a post like this from time to
time. Most of them make sense, and I indeed agree on it. But from my personal
experience, I prefer Clion to write C/C++, prefer IntelliJ to write Java. I
will not recommend Emacs for these coding job. A modern IDE is doing a much
better job. I still love the org-mode of Emacs though.

------
thinkpad20
I've been an emacs user for the last year or so. Previously, I'd used Sublime
Text, which I think is a fantastic editor. I loved its speed and especially
its simplicity -- pretty much everything just works right out of the box,
configuration is managed through JSON instead of some obscure imperative
language, etc. But ultimately I really needed two things: the ability to use
it over SSH, and the ability to run a terminal inside of it. (ST has a third
party shell plugin but it's frankly terrible). So much of my work involves
either SSHing into a machine to do work, or rapidly alternating between a
shell and an editor. The frustration of having to fumble my way through emacs
or vim every time I SSH'd into a remote machine, or having to hackily arrange
windows side-by-side so that I could get ST next to a terminal, ultimately
became too much and I decided to just start using Emacs.

At this point, I'm reasonably proficient at emacs. From the sound of it, I'm
nowhere at the level of the author of this article. But at least I'm
comfortable with the essentials -- copy/paste, find/replace, nagivation, etc,
and I can easily accomplish the two things I missed from ST (though I'm
getting increasingly fed up with the shortcomings of ansi-term, and I might
just switch to using tmux).

Unfortunately, what I've lost is the simplicity. I find emacs lisp to be a
horrible language. I find it ironic that a platform built on a functional
language like lisp manages to produce some of the most complex and
incomprehensible compositions of state, as different packages interact with
each other in a non-deterministic way, or one package will simply hijack the
editor and freeze/crash it, or refuse to let you enter input because a plugin
can't parse your buffer, etc. Have some weird behavior in your editor? How can
you tell which plugin is causing it? No one knows. It's really quite
unpleasant at times. Maybe vim would be better, or maybe not, but learning vim
would mean a period of being woefully unproductive or frustrated.

It's irritating that the only choices for terminal-based editors are either
embarrassingly under-featured (nano, pico, etc) or require a ton of learning
to become proficient in (emacs, vim). On the other hand, there are several
GUI-based editors which are powerful and easy, but none of them work in a
terminal, nor do they provide a terminal emulator of their own. :(

~~~
muraiki
I found [http://vim-adventures.com/](http://vim-adventures.com/) (no
affiliation) to be the best way to finally learn vim in the sense of actually
developing automatic muscle memory. It teaches you how to use vim using a 2d
game. It's worlds better than the built in vim tutorial, to say the least. :)

For a really different take on editors+shells, check out acme:
[https://www.youtube.com/watch?v=dP1xVpMPn8M](https://www.youtube.com/watch?v=dP1xVpMPn8M)

------
Tistel
lisp is beautiful. The crown jewels of computer science. getting to spend time
with it reminds you that programming can be fun (and profound) while you are
being paid to work with some awful drudgery language solving some stupid
problem. Being close to lisp, in this way, is like being at the same party as
Audrey Hepburn. It reminds you of grace.

~~~
snaky
Joel Moses has been credited with coining the phrase in the 1970s

APL is like a beautiful diamond - flawless, beautifully symmetrical. But you
can't add anything to it. If you try to glue on another diamond, you don't get
a bigger diamond. Lisp is like a ball of mud. Add more and it's still a ball
of mud - it still looks like Lisp.

~~~
progman
> Lisp is like a ball of mud. Add more and it's still a ball of mud - it still
> looks like Lisp.

Such claims are usually made by people who haven't discovered the power of
Lisp yet.

[http://www.defmacro.org/ramblings/lisp.html](http://www.defmacro.org/ramblings/lisp.html)

~~~
snaky
Such claims are usually made by people who haven't discovered the beauty of
APL yet.

~~~
progman
APL is actually beautiful. Watch the development of Conways game of life in
APL:

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

------
ksk
I find it interesting that we as programmers love to base a lot of our
technical decisions on hard data, but somehow the choice of editors seems
immune to this. Has anyone ever done an analysis of the actual objective
benefits of these editors? I got suckered into the 'religion' of vi and have
spent countless hours learning it to a fairly high level of proficiency over
the years. I don't think I've ever recovered all the time I spent. Maybe it
requires a special use case. Most of my time is spent outside of the editor -
reading specs/docs/code, debugging/tracing/analyzing existing code, or just
thinking about code.

~~~
rekado
> _Most of my time is spent outside of the editor - reading specs /docs/code,
> debugging/tracing/analyzing existing code, or just thinking about code._

Most of my time is spent _inside_ the "editor" (Emacs). Reading docs is in
Emacs, debugging is in Emacs, too. Thinking about code is assisted by `M-x
zone`... :)

To be able to stay in the same application in which I can use my home-grown
features on _everything_ that can be mapped to text buffers is an advantage; a
subjective advantage, maybe. I don't need to switch contexts as often any
more, and my brain thanks me for that.

I grew up on vim and got very comfortable with it, but elisp, interacting with
inferior processes, and the overflowing kitchen sink in general slowly
replaced my combination of vim+xmonad+tmux+terminal.

~~~
ksk
Ah, well I guess you're the lucky one :)

For me, most of the material that I need to reference is PDFs/Slides from
talks/Books/Web pages/My own hand written notes/etc - basically stuff that is
not plain-text. Luckily I have a multi-monitor setup, so I don't really pay
any penalty to switch contexts.

But keeping all that aside. As far as just the editing is concerned, all the
advanced features in vi and such do help if you're typing out reams of code -
something which I never find my self doing.

I suppose the obvious unstated thing here is that people have been productive
in all sorts of environments, from notepad to pico to visualstudio to vi. From
personal experience I find my self agreeing a lot more with people who say it
doesn't matter _that_ much.

~~~
rekado
I'm not one to argue about productivity. It's a term I never found very
meaningful, so I cannot be sure other people mean the same that I understand
when I hear the term.

For me it's not about lines of code per unit of time, but about what feels
right, and that's very subjective. Dependent on the task I can probably make a
decent amount of progress without Emacs, too, so I wouldn't argue that my
productivity depends on it. But this Emacs environment is molded after my
habits, so it's a really comfortable place, an extension of my body, much like
a good tool for wood working that fits your hand just right and lets you work
directly on an object without having to think of the tool as a mediator
between your body and the work piece.

I wouldn't work with computers if I didn't feel comfortable. Thanks to the
flexibility and hackability of Emacs I'm a lot more comfortable doing computer
work than I would be without it, meaning that I'll become a gardener a couple
of decades later than I would without it.

~~~
ksk
I agree with your view.

------
arvinsim
I just recently moved from Vim to Spacemacs.

I was looking for a TODO list application that would work on plain text. This
led me to org-mode. Fortunately, I discovered Spacemacs when trying to find a
plugin that would emulate Vim keybindings in Emacs.

All I can say is WOW!.

I get to keep all the modal editing goodness of Vim while getting the
excellent, well documented functions of Emacs. I also like it that the
commands are Vim-like(doing a sequence of keys using a leader key instead of
key chords).

------
agumonkey
Emacs grabbed my attention soon [1], I used to spend a huge amount of time on
almost all aspects of it. Now, I don't care[2]. Turns out editors are a waste
of time, at least if you consider them so[3]. Brilliant algorithms are short
in characters.

That said, Emacs is a full fledged system giving you a lot[4], if you're
willing and able to use that lever you'll be happy. Lastly, Emacs survived for
decades, it can swallow most interesting ideas that comes (ligthtable ?
checked [https://github.com/Fuco1/litable](https://github.com/Fuco1/litable)
[https://www.youtube.com/watch?v=mNO-
vgq3Avg](https://www.youtube.com/watch?v=mNO-vgq3Avg)).

\----

[1] It's syntactic system is powerful enough to feel different and more solid
(important) than other editors at the time (before Eclipse and IDEA). It was
repl-friendly, another factor that talked to my mind.

[2] It's still the 2nd most used program on my machine after chromium .. maybe
even a tie.

[3] Learn hard things, fundamentals (parsing, compilation, optimization,
paradigms), learn how to help yourself (see G.Bernhardt talk about unix
chainsaw[3]) in all possible ways.

[4] its open keybinding trie is still something that I miss in most programs
and I try to port a subset of it everytime I design a UI. It's also based on a
lisp, so enjoy using alien tools from the future. Btw, its git interface
(magit) blows Eclipse one out of the water for instance, most people wouldn't
suspect how efficient it is compared to heavy 'pro' tools.

------
maccard
I'd love to get started using emacs, but it's extremely difficult.

I want to use it to write c++ on Windows. I'd like to have autocompletion
support, and navigation support on a large project (>1million lines).

I have yet to manage to get it set up. If it were more straightforward to set
up and use, more people would use it I'm sure.

~~~
Scarbutt
Maybe this could help:
[http://tuhdo.github.io/c-ide.html](http://tuhdo.github.io/c-ide.html)

~~~
maccard
That's great looking. I'll give it a go today!

------
cryon
Emacs have been my main editor for 15 years soon and while it definitely got
some rough edges, once you learn all basic key-combinations for editing and
buffer management (which often is even more uncomfortable with a non us
keyboard layout) I feel that nothing else really compare. Text editing is
great but as many have pointed out the extensibility and all the high quality
community projects/modes out there make emacs something unique. I don't think
it's wrong to regard emacs more as an elisp environment than an editor.

The biggest problem with emacs right now as I see it is the lack of multi-
threading.

------
melling
Emacs and vim allow extreme customization for precision editing and
navigation:

[http://howivim.com/2016/damian-conway/](http://howivim.com/2016/damian-
conway/)

[https://www.emacswiki.org/emacs/AceJump](https://www.emacswiki.org/emacs/AceJump)

Worrying about startup time is the wrong problem. You want to optimize for
keystrokes, for example. More work, less typing.

------
craigds
I'm a recent ST3 to Atom convert.

I've used all sorts of text editors with a shell inside them, and I can't
quite fathom why you'd want to do that. What's wrong with bash running in
iTerm? Then it's a first-class citizen of your desktop instead of a subprocess
of a subprocess of a thing running inside another thing running in the one
terminal window you're using for everything.

I've tried using vim and emacs a few times, but I can't quite get to grips
with the whole modal editor thing. Feels like a whole huge learning curve just
for the sake of it, getting in the way of actually getting things done.

My _operating system_ is a perfectly good operating system, I don't need emacs
for that.

On the odd occasion when I need to edit something on a remote server (this is
_very_ rare, cos ansible/puppet) I'm quite happy using nano. It has zero
learning curve (no modes) and the few shortcuts you do need are marked on the
bottom of the screen. Yes it's kind of featureless, but you shouldn't be
editing things on your servers anyway.

------
tetheno
Emacs+Org-Mode can be an incredible platform for personal
information/knowledge management and quantified self.

------
rakel_rakel
The boilerplate argument against emacs is getting kinda old, isn't it? I used
vim exclusively for ~5 years up until last summer when I switched to emacs
which I use in more or less the same way, edit something, ctrl-z out to the
shell, fix something, fg back to emacs etc... I find the ~2 second startup
time for the times when I don't run it as a daemon negligible, and imho it's
easily worth it at least if you make use of some of the more powerful editing
modes.

Also the lacking a decent text-editor joke is just that, a joke :S

~~~
qnaal
> Also the lacking a decent text-editor joke is just that, a joke

well, noone's saying that viper-mode couldn't be improved

~~~
rekado
Or `evil-mode`. (I prefer `god-mode` as I have Emacs keybindings in muscle
memory and the vim bindings slowly fade from memory.)

------
amasad
I switched to emacs a year ago and I love it. I feel a lot more productive
when everything I need is in single window. However, just recently, I started
feeling what used to be minor RSI to be a major discomfort. There are days
where I can't type at all. I don't know if emacs' key bindings is mainly to
blame here, but it seems like it. evil-mode have been recommended to me but
I'm hesitant because I never liked vim's key bindings.

~~~
rekado
I recommend God mode. On my Thinkpad X200S I bind the mode switcher key to the
right mouse button, which is easily reached by the right thumb. With God mode
you don't have to relearn key bindings, you just no longer need to hit Control
and Alt.

[https://github.com/chrisdone/god-mode](https://github.com/chrisdone/god-mode)

~~~
amasad
This looks amazing, thank you!

------
soraminazuki
Why should people use emacs to run applications when the shell already does
that just fine? Just use the shell and you can run applications in any
language you want rather than having to stick with elisp. If you want to
constantly switch between applications, you can use tmux or simply your
terminal emulator's tabbing functionality. You can even switch between GUI
applications instaneously if you use a tiling window manager like XMonad.

~~~
rekado
Emacs _is_ my shell. You don't have to stick to elisp either, you just need a
little elisp glue. (The Emacs interface for the GNU Guix package manager, for
example, is written in Guile Scheme for the most part.)

Emacs is trivially extensible and whatever I make it do can be used in other
sub-applications. I can evaluate code wherever I want and change the system at
runtime. It's quite a different feel compared to having "unglued", ununified
applications.

------
pklausler
Emacs is a fine editor to use until you write your own. It's the only way to
make your primary interactive tool work exactly the way that you think it
should.

~~~
jnpatel
That's a hefty endeavor. Care to share more about your experience writing your
own?

~~~
maw
I think pklausler means that, out of the box, emacs is decent but, over time,
you slowly mold it into something that is more truly yours.

That's been my nearly twenty year experience with emacs.

~~~
pklausler
I am glad that you have enjoyed your use of emacs, but no, I was being
literal. A text editor is not a complicated piece of software to write from
scratch.

~~~
thinkpad20
I guess 7100 lines of C might sound simple to some, but that sounds pretty
complicated to me! :)

------
desireco42
I use both Emacs and Vim and Emacs is slow. Often I would issue commands too
fast for Helm to pick it up. It has rich environment and a lot going for it,
but it is slow. Excuse to have "full featured" environment does not stand
because Sublime Text is very much full featured and very fast.

Anyhow, while Vim is still my goto editor, Emacs has a lot going for it and I
fire it up when I work on Elixir because of superior support. Org mode is
nice.

~~~
nine_k
This entirely depends on the set of packages you configure. I was able to make
vim plenty slow by running too many plugins over too many files. I made vim
lightning-fast by keeping things simpler. I did both of the same to emacs.

Actually, advanced IDEs like Idea only feel fast because they do most of the
stuff asynchronously. Afaict neither vim nor emacs are excessively good at it.

------
mark_l_watson
I also love Emacs. I bought an original Emacs Manual for Richard Stallmam
(late 1970s?) and still spend a ton of time inside Emacs every day.

I do,use other editors like TextMate and GEdit and the JetBrains IDEs
sometimes. Right tool for the job. Emacs really excels for Lisp languages, for
me that is Haskell, Common Lisp, Clojure, and Scheme.

------
jhoechtl
Given the whopping size of Atom, I really wonder why anybody would call Emacs
big. Emacs was just ahead it's time.

------
miseg
[http://www.sachachua.com](http://www.sachachua.com) is the blog of an avid
Emacs user who promotes its use, and the plus is that there's a lot more
interesting information there too as she documents her journey.

------
wangii
I try Emacs around once per year. The problem is it's so slow under OSX. It's
much faster on my 2007 iMac running Linux than 2013 mbp. I even tried to run
it under X-Quartz but still performed poorly. What can I do?

~~~
DigitalJack
Turn up the limit on garbage collection made a big difference for me. I'll
post my .emacs.d on github and reply here.

I'd only make a personal recommendation for emacs if you were doing Clojure
development. Emacs+Cider+clj-refactor puts everything else to shame.

Otherwise I'd just say use atom or sublime or whatever ide.

~~~
pmoriarty
Just fyi, I also have huge issues with helm performance on my system. I tried
the (setq gc-cons-threshold 100000000) from your init.el, and it didn't help
at all.

I'm running emacs 24.5.1 with a recent helm on a 2-core 64-bit Linux system
with 8 gigs of RAM. Bringing up helm-mini takes about 7 seconds for me, as
does getting a response from helm-apropos when I type a single character or
even type control-g to close it.

The rest of emacs runs fine. It's only helm that has anything remotely like
this severe performance problem.

~~~
DigitalJack
I've never used helm, so I don't have any experience there. I can't say that
I've felt like I'm missing anything by not using it though.

I'll give it a try on my system, maybe that will give some insight.

\-- update \-- I installed a bunch of helm stuff, it didn't slow anything down
for me. try doing a clean pull from my repo and then adding your helm packages
and see if that helps.

emacs starts up in about 1.2 seconds for me.

------
yoanizer
Do you really think choosing between vim, emacs, textmate, sublime, etc is
going to make such a big difference in the end result?

~~~
rekado
To me the answer is "Yes".

What is the "end result"? Is it just a text file containing characters in the
desired order? Is the journey at all important or is all that matters reaching
the goal?

I have a feeling that most people commenting here have not actually read my
blog post; or maybe I failed to get my point across. Comparing Emacs with
other text editors is a different topic. I hardly even mention text editing in
the blog post.

Using Emacs for text editing is what I do because I'm already using Emacs for
everything else (or was it the other way around?). It makes a difference for
me because I can use the same malleable system for everything that can be
mapped to some text representation. Emacs modes enhance that text
representation, make it alive (e.g. hyperlinking in man pages, shells in
Emacs, REPL interactions, M-x compile, etc).

------
kop316
Out of curiosity, I have tried Vi and Emacs, but the CLI text editor I have
gone back to is GNU nano.

Am I missing something?

~~~
rekado
It depends on what you want to do and what you expect. As I wrote in my blog
post, Emacs is more to me than just a text editor, just like a browser is more
to many people than just an HTML viewer.

I don't use Emacs on the command line; I use a graphical instance. I usually
only have two programmes open: Emacs and a graphical browser (eww still needs
some work).

Being able to use my very own Emacs that has been molded according to my
habits for pretty much _every_ task is a great feature, but it only becomes
obvious after some time of continued usage.

------
pandeiro
It just amazes me that programmers would use anything else.

------
j0e1
Long live Emacs! It just C-w 's all competition.

------
yarrel
Because it's awesome.

------
ktamura
Any Acme users here?

~~~
autoreleasepool
Which acme user are you, Russ or Rob?

~~~
ktamura
Neither, actually. In fact, I don't even consider myself to be a programmer
(Although I routinely write scripts of sorts)

------
ebbv
This article seems to assume that people who criticize Emacs don't understand
that Emacs isn't a monolith, and that the various features are modules. I'd
guess the majority of people who say "Emacs is bloated" do get this. The
author fails to understand what people really mean by this criticism.

I'll just speak for myself here, because that will make phrasing easier; the
point is that for me a text editor doing most of the things the author
describes (running shells, handling email, todo lists, etc.) makes no sense.
For me, a text editor should first and foremost be a great text editor.
Secondarily it can be nice to have integration with Git or other tasks that
are intimately related to the files I'm going to be editing with the editor.
But why would I ever want my editor to do all those other things? I have a
window manager for that. Or at least a shell.

The comparison of Emacs to a shell kind of illustrates my point; a shell only
exists to facilitate managing of files and processes. It being able to run any
command you want is its whole purpose. Emacs was originally an editor, and the
community grew its capabilities from there. (I'd argue that it grew during an
era where it having so many modules with so many capabilities made more sense
than today, but that's another conversation.)

The comparison of Emacs to a web browser is better than the comparison to the
shell. But this comparison still misses the mark, because browser based apps
have several advantages (and disadvantages) over native apps, they are
fundamentally different because of the technologies involved.

Using Emacs to do things like email, manage your shell sessions, etc. is a bit
different from running another mail client, or running separate shell
processes, etc. but they are not fundamentally different from each other in
the same way. Whether you're running Emacs locally or remotely, you can run
separate mail clients, etc. the same way.

Anyway, my point is not that Emacs has no reason to exist, but it comes down
to this; personal preference. The only reason to use Emacs the way the author
does is because you like it.

------
calibraxis
"Doing just one thing and doing it well" \-- which is better at this, Unix
programs or Emacs functions?

~~~
eru
At least Unix programs don't suffer from dynamic scope. (Unless you use bash
to glue them, of course.)

~~~
rekado
There are some instances where dynamic scope actually is not as insane as it
may seem. Although the paper is probably dated and opinions have changed since
then I can still understand that there are practical reasons to dynamic scope
in some instances:

[https://www.gnu.org/software/emacs/emacs-
paper.html#SEC18](https://www.gnu.org/software/emacs/emacs-paper.html#SEC18)

All my own Elisp code uses lexical scoping by default and I don't trust myself
enough to use dynamic parameters liberally in my code. But I don't think it's
entirely unreasonable to have the ability to dynamically override internals.

~~~
eru
Oh, definitely. Even extremely statically minded Haskell offers a dynamic
scoping construct: the reader monad. (As Haskell is wont to do, this monad
infects every user of it with a `tag', just like IO does. No silent surprises
from dynamic scoping here.)

~~~
mbrock
Implicit parameters, too.

------
bunkydoo
I love EMACS, partially because of those zippy the pinhead quotes that can be
evoked with the 'M-x yow' command

------
officialchicken
Different people like different things, OK? A 40 year old flamewar is boring
and old. Just let it die.

[1] [http://unix.stackexchange.com/questions/986/what-are-the-
pro...](http://unix.stackexchange.com/questions/986/what-are-the-pros-and-
cons-of-vim-and-emacs)

~~~
to3m
I think this is a misreading of the article!

~~~
rekado
Indeed! I was actually raised by a pack of vims, and I like both editors. I
used to use evil-mode in Emacs for a while until I reset my muscle memory by
switching to dvorak.

I have no interest in old flame wars. Our generation has its own set of flame
wars to fight ;)

