
Emacs: The Editor for the Next Forty Years [video] - rgrau
https://media.emacsconf.org/2019/26.html
======
jwr
There are lines in my Emacs config files that are older than some of the
programmers I work with, so I can relate.

Contrary to what some people think, Emacs does not require constant tweaking
and wasting time on configuration. I revisit my setup every couple of years or
so, and I always find it is time well spent, as my productivity goes up as a
result.

I do not know of a better environment for multi-language programming, and I
often look around and try different things to see if they match up.

~~~
dleslie
And it will only get better once it understands LSP, better than it does now.
It's a pale copy of VSCode's incredible LSP implementation: for a user, simply
clicking the button to install the extension automagically configures a fully
functional language environment; even for C++. Most of the time.

When last I tried to get decent C++ support working with Emacs, about a year
ago, it was still a mess of compiling rtags/cquery, installing global,
configuring per-project variants, sacrificing ungulats, hail baphomet.

~~~
jdormit
I've been using Emacs' lsp-mode ([https://github.com/emacs-lsp/lsp-
mode](https://github.com/emacs-lsp/lsp-mode)) for professional Python
development for months now and it's been a great experience. It requires a
little more work than I'd like to get it working with virtual environments
(making sure the LSP server process is running in your venv, mainly), but I
would argue that's a problem with the Python ecosystem, not lsp-mode itself.

And for statically typed languages (I've tried Rust and Go) the lsp-mode
experience is flawless and works out of the box.

~~~
jonnycomputer
I switched from emacs to Pycharm for python development, out of frustration
with what most packaged tools was getting me, relative to what PyCharm did
with no effort and little frustration at all. Too many half-maintained
packages, put together, fighting incompatibilities.

However, LSP really may change that.

~~~
theCodeStig
LSP will definitely change that.

------
mickeyp
Emacs turns disjoint environments, languages, and activities into a (mostly)
streamlined system of workflows and idioms.

Explaining just how powerful that is to people who don't use Emacs is
difficult. People need to sit with you for an hour or so and watch you work to
truly appreciate just what that means.

~~~
klik99
There's a certain class of programmers tool that requires constant tweaking,
like a road bike used in the city - and typically the users suffer from OCD or
stockholm syndrome, because they won't stop evangelizing.

I thought emacs was one of THOSE types of tools and the initial experience
does nothing to disabuse that. On my 4th or 5th attempt to start using emacs I
finally decided to get over the hump even if it took weeks of being slow.

I'm sure it's the same story for every emacs user - I literally never turned
back. And I don't think I've touched my dotfiles in 2 years. But I get why it
looks so esoteric from the outside.

~~~
microcolonel
The more I use Clojure at work, the more I tolerate the elisp side of things.
I've written a couple little major modes (though not to any great standard of
quality) and elisp is indeed pretty crap, but usually adequate. I think the
ideal Emacs lisp successor would be a Clojure derivative, with the buffer
represented as a persistent trie datastructure like other things are in
Clojure. Maybe the buffers could be disjointed from the presentation a bit,
and we could have strictly AST-driven major modes, rather than the (admittedly
quite usable) hack that is paredit.

~~~
Myrmornis
> Maybe the buffers could be disjointed from the presentation a bit, and we
> could have strictly AST-driven major modes

Yes, good point, agree that would be a very positive direction.

> elisp is indeed pretty crap

Ah, I've been enjoying it a lot recently :) But I don't have an excuse to
write clojure and I certainly recognize that that's a much more sophisticated
thing.

What are your biggest criticisms of elisp? Mine is basically that the naming
of functions in the standard library is terrible.

Also: I'm still a bit confused about whether I should be using lexical binding
(probably my fault for not thinking about it hard enough); the situation with
threading is a little obscure; on the face of it threads in now exist in the
elisp API, but are they not fully featured in some aspect?

~~~
microcolonel
My main gripe with elisp is the default to dynamic binding, which is in most
systems almost never what you want. In Emacs, the dynamic bindings are used
for more productive reasons than in generalized programs, but they should
still be a conscious choice.

When it comes to threads, the elisp datastructures are inadequate because they
are mutable. It is possible to write functioning threaded programs with shared
mutable state, but for the most part, it is going to introduce the kinds of
bugs that people solve one of per week on a six figure salary.

~~~
yyoncho
Use dash/s/f/ . seq is fine too but dash is pretty much clojure port.

~~~
microcolonel
Dash is a very cool library! Though it only really does seq. The Clojure
persistent vectors, hash maps, and hash sets are all very powerful. CHAMP is
often an improvement on HAMT.

I think the text buffer as a persistent vector of extended grapheme clusters
is an interesting thought.

------
nandkeypull
Emacs has really undergone a renaissance in the past decade - magit, LSP, ivy,
spacemacs, doom emacs - there have been so many novel new packages and
frameworks written by elisp hackers.

For such an old editor, the development scene feels incredibly alive.

~~~
slightwinder
There may be much going on with emacs, but so far it fails to move ahead. The
project is just improving the old strenghts, but not fixing the old fails. And
as time moves, they start to hurt more and more and more until they break.

~~~
na85
What are some old fails that need fixed?

~~~
sooheon
One thing I notice: too many things cause unresponsiveness. 8 cores in my
laptop and I can't install a package in the background, and semantic parsing
interrupts typing. There doesn't seem to be any concurrency at all, things I
do every day like eval'ing forms to REPL cause stutters.

I love that it allows makers to explore new ui paradigms (magit, lispy), but
performance is its biggest downside.

~~~
ibrahima
[https://github.com/Malabarba/paradox](https://github.com/Malabarba/paradox)
lets you install packages async, by the way.

~~~
sooheon
That looks like an interactive ui--I can't declare use-package forms in my
init.el, and have the initial install and any updates be async and concurrent.

------
Isamu
(from the slides)

>I learned Emacs in September, 1983

>It is now November, 2019

>...that’s over thirty six years!

>An amazingly long time.

Hmm, I think I learned Emacs around the same time. Yes, sometimes I think it
is weird that I'm still using it.

I get a lot of pushback when I say that the developer environment hasn't
advanced amazingly in all those years. Devs will point to one or more rather
small incremental improvement. I'm sorry but I think we are still in the
Bronze Age of programming.

~~~
worldsayshi
The main reason I quit Emacs was the lack of context and semantically aware
code completion and re-factoring tools. Such tools are invaluable productivity
boosts for me. I have never gotten that to work in Emacs to a satisfactory
degree.

~~~
billfruit
OTOH hlmost many modern IDEs can't even open two copies of the same file and
display it side by side or record arbitrarily complex macros and play them
back any number of times.

~~~
dmortin
Completion and refactoring are much more important than these.

When working with code it's very powerful to work on a higher abstraction
level. E.g. move this method to an other class and update all references to it
automatically keeping the code correct. It takes a few seconds in a modern IDE
while in a text editor you have to do most of it manually.

When you get used to the power of refactoring, you start to use it more and
more, like a sculptor getting a more powerful tool.

Open source editors should pool their resources to create such powerful
refactoring tools which can be accessible in any editor via LSP or something.

~~~
gmueckl
The sad part is that text based representations of programs are holding back
programmer productivity by raising the bar for these refactoring tools
unreasonably. If programs were represented and edited directly as syntax
trees, 80 to 90 percent of the complexity of refactoring tools would go away.

~~~
dmortin
On the other hand, when writing new code it is quite efficient to simply type,
supported with proper completion.

It would be much less efficient to create a program in a point and click gui,
dragging visual elements onto the syntax tree.

So both is necessary. Efficient text editing is required to work quickly with
the code, edit things locally efficiently. And refactoring is also needed if
you want to perform bigger operations which span methods or classes.

An efficient text editor with completion + powerful refactoring. This is the
winning combination.

~~~
gmueckl
You're jumping to conclusions when you're associating a syntax tree based
program representation with the forced use of a mouse or cumbersome navigation
for editing. Nothing could be further from the truth. A completely usable and
fast keyboard based editing method for such a program representation is
entirely possible. The only downside is that it's harder to create a minimal
working version of such a tool compared to a text editor.

~~~
dmortin
It may be possible, but I haven't seen such a tool. I have seen tools where
you edited the syntax tree via a GUI and it was terrible for writing code. It
may work better for tree modifications.

Text programs are pretty efficent when writing, editing code, because you can
access a large number of elements quickly with the syntax.

E.g. writing let a = 3 can be much quicker than starting some command palette
from the keyboard, choosing the "declare variable" action and then fill some
dialog with the name and value of the variable.

I have doubts it can be made as efficient as typing, otherwise we would have
seen such prototypes already. Have you?

~~~
gmueckl
I am working on one.

------
iudqnolq
I'm new to Emacs, but enjoying it very much. Just got mu4e working with Gmail
XOAUTH2 (for a G Suite account that the administrators have implemented their
own "delightful login experience"). Would there be any interest in reading a
writeup?

~~~
TeMPOraL
Definitely. I approached the set up mu4e + offlineimap over multiple accounts
(including a GMail one) many times, and I've never been fully satisfied with
it. I'd really want to get it to work flawlessly, so I'd love to be able to
learn from your experience.

~~~
iudqnolq
What doesn't not fully satisfied mean for you? I might just have lower
standards...

~~~
emgee_1
I think you should offlineimap; Use mbsync ( iSync )

~~~
iudqnolq
Offlineimap and mbsync are two separate tools that do the same thing. I've had
a good experience with offlineimap. In both cases, however, the hard part is
not picking the tool but configuring it.

------
freetonik
I hope you excuse me for a shameless plug, but it seems like a relevant enough
thread to share my podcast about Emacs:
[https://emacscast.org/](https://emacscast.org/)

While it might seem strange to discuss a text editor in the audio format, I've
been getting positive feedback on this project as I try to talk more about
underlying philosophy and mindset, not specific details or settings.

~~~
spudlyo
My feedback for you is you need to give listeners a reason to keep listening
to your podcast right away, you simply can not go on a meandering personal
discussion about yourself for the first 10 minutes of a podcast and expect to
retain my attention.

~~~
Koshkin
Well, that wouldn't be much different from the pervasive habit of many authors
of YouTube videos to stick their own faces in the frame in one or the other
ridiculous fashion. This is unsurprising, because it is self-advertisement
that is the true goal of such podcasts and videos.

~~~
Myrmornis
I routinely follow one podcast (Software Engineering Daily) and one You Tube
channel (3blue1brown). Neither fit your characterisation. Perhaps you should
consider being a little more selective in your consumption of YouTube :)

------
jordigh
So the slides say...

> Concurrency safety isn’t an accident. So far,only Rust has a good story on
> concurrency thanks to its type system.

Is that really true? I've really enjoyed concurrency in D.

[http://jordi.inversethought.com/blog/advent-
of-d/#day18](http://jordi.inversethought.com/blog/advent-of-d/#day18)

How much better can it be? And yes, D's concurrency is also based around
types.

~~~
fluffything
> How much better can it be?

Rust guarantees that a data-race is a compilation error.

D.. does not guarantee anything.. a data-race won't even give you a run-time
error..

So... since going from D to Rust is going from zero to all guarantees, I think
it is fair to say that Rust is technically infinitely better.

FWIW this is not D's fault, most safe mainstream languages do not guarantee
the absence of data-races (e.g. Java doesn't guarantee that either).

~~~
0xffff2
There's a lot more to correct concurrency than data races, although they are a
big factor. I think it's more fare to say that going from D to Rust is going
from zero to some guarantees. Still technically infinitely better.

------
xvilka
There is an amazing project of converting Emacs into the more modern language
- Rust (the C parts of it). It is called REmacs[1]. It is sad that the port of
Emacs to Guile[2] didn't work out. And for the people who want to convert
their C code to Rust, I quite recommend trying c2rust[3] transpiler and
refactoring tool.

[1] [https://github.com/remacs/remacs](https://github.com/remacs/remacs)

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

[3] [https://github.com/immunant/c2rust/](https://github.com/immunant/c2rust/)

~~~
rtpg
reading the GuileEmacs thing it sounds like the project was a success? Is
there pushback against using this upstream?

~~~
bjoli
Guile is supposed to be the GNU extension language, which meant there was a
political incentive for guile Emacs, but it was never asked for by the Emacs
people. Considering the amount of bikeshedding going on for faaaar less
intrusive changes to Emacs, I have doubted guile Emacs success for a long
time.

Guile now runs elisp, although there is a lot of low hanging fruit left when
it comes to optimization. Guile is shaping up to become a very neat little VM,
with proper threading, JIT compilation, and delimited continuations.

I think the idea of elisp running outside of Emacs, with access to all of the
gory glory of Emacs libraries sounds fantastic. Imagine org-mode and a (emacs
PKG org-mode) library you can use outside of Emacs with a sub 0.1s startup :)

------
Zelphyr
I've been writing Clojure lately but I'm a greybeard (literally) Vi/Vim user.
vim-fireplace is nice but I can't help wonder if I'm losing something by not
using Emacs. At the same time, Clojure is so wonderfully different from the
other languages I know that I don't feel like I have the cycles to learn a new
editor at the same time I'm learning a new language. Then again, maybe that's
the best time to learn Emacs?

~~~
jdormit
I've never used Fireplace, so I can't speak to the comparison. But CIDER (the
Emacs Clojure IDE) is an utter joy to use - I can't recommend it enough. If
you do try it out, I would be interested to hear how it compares to Fireplace.

------
nonbirithm
If Emacs is to be "the" editor for the next forty years, I really hope it can
better combat random hangs. As someone who uses Emacs as a daily driver and
loves it to death for its extensibility paradigm it's painful when it maxes
out the CPU, I have to restart and have no idea what it could have been.

But then again scripting languages don't really have these interruption
features by design. I'm developing something with a scripting layer and
occasionally come across accidental infinite loops myself. I wonder what e.g.
Factorio or Minecraft do if a mod enters an infinite loop. If the answer is
"program more carefully" and "don't use badly coded mods" then I guess it
can't be helped.

Proper concurrency in elisp can't come fast enough. At least then we could
have a task manager to kill hung threads with.

~~~
michael-ax
(setq-default garbage-collection-messages t) ??

~~~
Koshkin
Right - that's what I need from my text editor!

~~~
sc4les
*OS

------
omarhaneef
I've noticed that (almost?) any talk about any editor in the last few years:
emacs, vim, sublime, atom etc always brings up how good VS Code is.

It's a huge endorsement of VS code.

~~~
thatguyagain
I think users of VI or emacs has different ways of defining "good" here.
Personally, I would never use VS Code, or any other chromium editor.

~~~
tendencydriven
Is this due to some notion of it being slow? VSCode is fast, native-fast. With
a fantastic plugin ecosystem

I've been a full-time Vim user for the past decade (now NeoVim) but I've
seriously considered switching, VSCode with vim mode turned on is truly
fantastic, it's just not portable enough for my needs.

~~~
saagarjha
> VSCode is fast, native-fast.

Not when starting up…

~~~
tendencydriven
I'd consider startup time the least important metric for measuring speed of a
text editor - as long as it's not ridiculous.

Important speed metrics for me are: Switching between buffers

Scrolling up/down a page (vim used to be terrible for me before i switched
terminals to Kitty)

Substitutions

Search

------
k33n
Oh Emacs. A graybeard I respect got me to try it about 5 years ago. I used to
walk by his machine and think "wow, in a movie about a hacker, this is what
their computer screen would look like". I also thought Magit was pretty damn
cool because it made interacting with Git extremely intuitive (once you're
comfortable with Emacs).

In the years since first picking up Emacs, I have probably spent 100 hours or
more configuring it, reconfiguring it, refactoring my configuration, and other
things that wasted my time I'm not going to make the world a better place by
configuring my editor. I'm going to do it by shipping code.

I'm a recovering terminal junkie. I had a problem. I was bored with my work so
I wanted to challenge myself. Maybe I even enjoyed procrastinating a little.

~~~
SirensOfTitan
So if you’re not making the world a better place you’re wasting your time?

Play is supremely important in almost any activity. Not only is there
incredible work insight to be found in activity without goals, but play is fun
and good for you.

~~~
kashyapc
On the importance of "play"—

From one of the books I'm currently reading ( _Blueprint, The evolutionary
Origins of a Good Society_ , by Nicholas Christakis — itself a great read), I
learnt of an interesting book reference: _Homo Ludens: A Study of the Play-
Element in Culture_ (1938).

The abstract sounds promising:

 _" [...] With cross-cultural examples from the humanities, business, and
politics, Huizinga examines play in all its diverse guises—as it relates to
language, law, war, knowledge, poetry, myth, philosophy, art, and much more.
As he writes, “Civilization is, in its earliest phases, played. It does not
come from play like a baby detaching itself from the womb: it arises in and as
play, and never leaves it.” [...] Starting with Plato, Huizinga traces the
contribution of “man the player” through the Middle Ages, the Renaissance, and
early modern world. [...]"_

[*] [https://www.amazon.com/Homo-Ludens-Study-Play-Element-
Cultur...](https://www.amazon.com/Homo-Ludens-Study-Play-Element-
Culture/dp/1621389995)

------
petilon
I have been using Emacs for about 20 years, and I love that you can use it on
Windows and Linux and character mode and GUI. Love the programmability and the
keyboard shortcuts.

Where it sucks though is programming language smarts such as "intellisense"
completion. Even something basic such as syntax coloring doesn't work reliably
--depends on the mode implementation and most of them are buggy.

I get by in other editors such as Visual Studio and VSCode by downloading
emacs emulators.

~~~
na85
Intellisense was something I was missing for years. I contribute to a large
C#/netcore project and it was a pain to use emacs until I discovered
OmniSharp-Roslyn[0].

Auto code completion works pretty much flawlessly for me now.

[0] - [https://github.com/OmniSharp/omnisharp-
emacs](https://github.com/OmniSharp/omnisharp-emacs)

~~~
OrderlyTiamat
I have never got omnisharp to work reliably- spent quite a bit of time on it,
too. I'm wondering if I should try again or just give up...

------
dragonsh
The reason I use emacs over vscode is due to the reason, that it does not
waste cycle in rendering html, use irc instead of slack and discord, and does
one thing very well which is processing and rendering text.

Emacs inspired me to take on and understand functional language. Rust still
feels an incremental improvement with memory safety over C.

I believe C is unfairly criticised. C has it’s own drawbacks but it is one of
the language which really gave me power to tinker with hardware directly and
it was refreshing. Rust may be a great language in design but didn’t generate
that feeling of directly able to work with hardware as I had when I used basic
peek and poke and later C.

If org-mode, text processing and lisp stays with emacs it will continue to
survive for next 40 years. Yes it needs constant evolution but I do not agree
with the list like renedering html, working with slack.

------
innagadadavida
Fabric Bellard’s ema s port (QEmacs):
[https://bellard.org/qemacs/](https://bellard.org/qemacs/) It’s amazing how
fast it is. Unfortunately it is not fully compatible and missing many
features.

~~~
Myrmornis
It doesn't have an emacs lisp interpreter right? It's funny, for me, emacs is
emacs lisp. I sort of don't understand why one would emulate emacs without a
lisp interpreter (given it's Bellard I'll probably find out I'm wrong and it
does have a complete emacs lisp interpreter).

------
threatofrain
People who use Racket on Emacs might appreciate Racket Mode, which I only
recently discovered:

[https://github.com/greghendershott/racket-
mode](https://github.com/greghendershott/racket-mode)

------
superbaconman
As an emacs user I like the little rant about keyboards towards the end
(54:27). It's stupid hard to find a laptop with good keys, good layout, good
internals, and good battery.

~~~
GrayShade
I'm partial to the Emacs keybindings, but you you're so right about the laptop
keyboards. Mine doesn't have an End key (Home, PgDn, PgUp, Power).

~~~
mickeyp
The benefit of Emacs's keybindings is that they're the default keys used by
GNU readline (though it also supports Vi-style keys.)

That means when you know that Ctrl+E and Ctrl+A (`C-e' / `C-a') goes to the
end or beginnings of a line in Emacs, you know it'll also work in your bash
shell (or indeed any tool that uses GNU readline.)

~~~
GrayShade
That's what I'm using while coding, but it's not friendly to all software
(e.g. browsers or other programs that don't have configurable keyboard
shortcuts).

~~~
waterhouse
This is one of the things I like about Mac OS: text fields, by default, have
the readline keybindings. In the box where I'm typing this comment in Firefox,
I can use control-{a,e,n,p,f,b,d,h,k} just like I can in the shell. This is
one of the reasons I haven't tried harder to use a Linux desktop.

------
ph2082
Emacs (and may be Vim) - Not sure, but seems like it got support for all the
programming languages under sun.

Thanks to all those awesome people who put effort over the years.

~~~
sc4les
My killer feature is when you want to streamline your workflow. Adding a new
test runner on VSCode for your favourite language? Possible but takes a lot of
effort to get right. Adding one in emacs? I can inspect the source code or my
language bindings and add/change the command it’s running. In a few dozen
lines of elisp I can add shortcuts to all my daily tasks and even combine
them. Search for an error message I get in my tests on Honeybadger? Check. Run
code snippets in org mode against my local machine and export the whole
document as PDF or markdown to our wiki? Saves me a few minutes here and there

------
selfishgene
Could TeXmacs solve some of the problems mentioned in the slides?

[http://www.texmacs.org](http://www.texmacs.org)

TeXmacs is based on Guile and there is apparently already a Guile-based
implementation of Emacs that is near feature complete.

Perhaps a Guile-based Emacs could somehow be embedded as an elisp-compatible
interpreter "back-end" inside TeXmacs, much like how Mathematica is separated
into a kernel (for computation) and a front-end (for input and rendering) that
communicate with each other over a protocol called MathLink.

There is also DomTerm from Per Bothner, who perhaps coincidentally has also
worked hard to produce his own Scheme-based version of Emacs (by way of the
JVM).

[https://domterm.org](https://domterm.org)

One of the downsides of TeXmacs is the significant keystroke input latency
caused by the extensive amount of page redrawing that is often required when
editing "rich text." It's one of the main reasons that many still prefer
latex-preview mode inside Emacs instead. Maybe latency would be less of an
issue inside a graphics-aware terminal emulator like DomTerm.

------
jypepin
I really started to get lost when he started talking about never wanting to
leave his text editor, wanting to read his emails in Emacs, browse the web in
Emacs, have slack and discord in Emacs, etc.

Serious question: Why? Is it that hard to alt+tab? Especially, why would you
want such distracting features inside your editor, while you are trying to
focus and work?

~~~
ant6n
> Is it that hard to alt+tab?

incidentally, alt+tab is broken on MacOs. It cycles between programs, not
windows - so if you have mutiple terminal windows open, you're screwed. You
can use the alternative alt+` to cycle between windows of the same app, but
that doesn't go to the least recently used window, but cycles through them in
order - which is also useless when having many terminals open. Then you can
pay like 15$ to get a tool like witch (just to get basic OS functionality),
but that tool is slow and broken.

So on a Mac it can be pretty hard to alt+tab.

~~~
chapium
I don't get where that is broken.

~~~
ant6n
On other operating systems, alt+tab goes to through the list of least recently
used windows. So when working between two windows, one hotkey switches between
them. On Mac, that's not possible if the two windows are part of the same app
(or also when windows are distributed across multiple work spaces).

~~~
sooheon
Being able to switch between apps, windows, and tabs is different from just
windows and tabs. I prefer the former because the hierarchy allows you to find
arbitrary things with fewer keypresses overall (as opposed to mashing alt-tab
through a long flat list).

~~~
ant6n
Except there's no such capability.

------
Myrmornis
I've been using Emacs for 15 years or so.

I recommend Emacs to anyone who thinks it would be fun to use Lisp to
configure a text editor, even if just a bit. However, that is an "if and only
if".

If you choose to go beyond using emacs lisp for configuration, then I would
say that emacs-lisp is an extremely fun and productive environment to work in:
many programming languages give you a good standard library and package
ecosystem, but with Emacs lisp you not only get that, but from the outset your
project will be born into a mature and extremely fully-featured text editing
environment. It's possible to create useful projects with a very good feel,
with relatively few lines of code. If you don't have another excuse to use a
lisp in your life, this is a very good one.

I would like it if Emacs would stop distributing itself with the ridiculous
splash screen and 1990s menu icons.

------
ReneFroger
I struggled a lot with my Emacs setup, and developing for clients and
languages. But I was able to puzzle my pieces together with
[https://emacs.zeef.com](https://emacs.zeef.com) , it is your friend

------
justaj
A question for Emacs user: Do you use the GUI version or the terminal version?
I found the terminal version next to unworkable because I couldn't find any
terminal that didn't capture some keystrokes that were meant for Emacs.

~~~
dmortin
GUI. Why should I use the terminal version if I work at a GUI. If you have SSH
then you do not even have to log in to sites, to run emacs. Just use Tramp.

------
arminiusreturns
On the note in the video about irc, I think there is room to update irc but
keep it going. Right now as an in between I'm leaning towards a mumble/irc
setup. The only other two things that really catch my eye are matrix and
mattermost (which has a jitsi integration).

I hate the trend to proprietary chat apps so much. After years of ventrillo
and teamspeak, around 2009 I discovered mumble and was using it for years, but
in the last ~1year or so everyone started switching to freaking Discord and it
drives me crazy.

------
aurelien
Emacs is an extensible editor ... It just need to be adaptive now to
programming language evolution.

If Lisp have make the job from a while it should be nice to keep that
solution, but, to had more flexibility for next generations.

A simple example, I works with it every days, IRC, mail, web, source code ...
but on Ycombinator, I need to load an html browser to vote ... But yes I works
out of Xorg ... and that is an important value that most of editor just don't
understand.

Thanks for GNU Emacs, I really love it.

------
eruci
I've never seen the need to use anything other than vim.

~~~
alpaca128
Same here. I've tried getting into Emacs for a couple days but gave up. It
would mean a lot of effort just to achieve a similar proficiency, for little
gain(better syntax highlighting, a few small features).

I think the deeper you're already in one of the ecosystems the harder it
becomes to switch and the returns diminish further. In my case I'm very
comfortable with Vim combined with a tiling window manager and terminal
buffers, and I can't stand Emacs' control scheme. So at this point it's simply
not worth it.

~~~
spudlyo
Emacs has recently been seeing a lot of growth from vim users who are
migrating to emacs "distros" (like spacemacs and doom) that are pre-configured
with emacs' vim-emulation.

I found this video[0] a pretty interesting perspective from a die-hard vim
user who switched.

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

~~~
alpaca128
I've tried those already. Evil, Spacemacs, Doom. All except Doom have a
misbehaving Escape key, Spacemacs needs as long to start up as one of the
Electron-based editors.

In the end it comes down to this: I don't need Emacs. I've tried to find a
feature that I really want and that's worth it to switch for(yes, I also tried
org mode). But I'm comfortable with my Vim setup, I don't need an email client
or web browser in the text editor.

------
cheez
I'm on 20 years now, can easily see it going 40 more.

------
gchamonlive
I am considering buying Intellij IDEA ultimate. Been testing pycharm Pro, and
docker integration for specific OS settings, remote debugging, refactoring
tools such as method extraction, package conversion, and terraform integration
is a breeze.

Any way I could set such an environment up in emacs?

~~~
theCodeStig
JetBrains editors are superbly good at refactoring, IMO that's their one only
advantage.

Consider working primarily in an editor with LSP support (such as Emacs) and
use JetBrains on the side solely for refactoring. Wean yourself off of
JetBrains, as LSP improves.

------
rvz
> Emacs support is on by default in MacOS.

Given that the author is siding with the usability of macOS with something
like Emacs over using it in a GNU/Linux distro is somewhat a surprising
discovery and perhaps an insight into the falsehood of having a 'consistent'
Linux Desktop; even for power-users like the author.

If one has to go through a maze of settings and config files to configure
Emacs shortcuts to work 'consistently' on either a GNOME or KDE desktop even
for a typical developer, then I would at first question myself if such an
endeavour is 'worth it' for something as arcane as Emacs.

While it was a great spectacle to watch the Vi/Emacs wars, I'm afraid that I
would favour getting my work done on my MacBook, thank you very much rather
than messing around with something that could be easily mistaken as the editor
for the prehistoric years.

~~~
na85
I use the railwaycat port of emacs, which is frankly what any macos-based
emacs user should use. I provides smooth scrolling, an interface with
applescript, touch bar support, and lets you use os-native hotkeys including
Command-as-Meta.

~~~
spudlyo
I agree that the Mitsuharu version of emacs is pretty great on the Mac, but
the lack[0] of multi-tty[1] support is a deal breaker for me. I like emacs-
plus[2], which while not quite as nice as the railwaycat/mitsuharu version,
allows me to run text frames and GUI frames on the same server process.

[0]: [https://bitbucket.org/mituharu/emacs-mac/pull-
requests/2/add...](https://bitbucket.org/mituharu/emacs-mac/pull-
requests/2/add-multi-tty-support-to-be-on-par-with/diff)

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

[2]: [https://github.com/d12frosted/homebrew-emacs-
plus](https://github.com/d12frosted/homebrew-emacs-plus)

------
swah
I changed Emacs for Sublime and now VScode - my main reason to change IIRC was
that my fingers/wrist hurt from using chords so much :(

~~~
dmortin
You should have simply switched to sticky keys, so you don't have to press
keys simultaneously:
[https://en.wikipedia.org/wiki/Sticky_keys](https://en.wikipedia.org/wiki/Sticky_keys)

Also, you can change the keybindings.

~~~
swah
I tried a few times, but could not go from "pressing at the same time" to
"presssing in a sequence". I just "chorded"...

------
thibran
The idea of Emacs will survive, that's quite sure. The editor, I wouldn't bet
on this one.

------
lxbarbosa
authors seems to not know melpa and is away from emacs news.

eglot is about to ship into emacs core, emasc has pdf reader for decades and
remacs is a rewritten of emacs in rust, that had contributiuon from emacs core
devs too.

and guile is ready to use into emacs as a alternative to elisp

------
sys_64738
With emacs it feels like I can do almost anything.

------
commandlinefan
Emacs - the editor that STILL doesn't have a simple way to duplicate the
current line?

~~~
benreesman
I think the germane point about Emacs here is that some people like writing
Lisp and some people hate it. If you hate it Emacs is likely not going to be
your best environment, and that’s fine.

I really like writing Lisp so Emacs has a simple way of doing anything I want,
but it’s not for everyone.

~~~
bachmeier
I think this is a larger problem with Emacs. Duplicating a line is something
that should be easy to do out of the box.

And if it's a situation where you really need to make the user define a
keyboard shortcut, don't make them do C-c followed by the actual shortcut, let
them define single keystroke shortcuts to do what they want. Multiple
keystroke shortcuts are so damn annoying.

~~~
globular-toast
Why? I can't think of any time when I've wanted to duplicate a line.

~~~
bachmeier
Well, there are a lot of things I don't want to do, but that doesn't mean
others don't want to do them. As these things go, it's a fairly common
operation.

