Forking it is also missing the point. There's plenty of forks with dark coloring schemes and predefined packages. Spacemacs, Doom emacs, etc. The issue is that most people hear about emacs and try to download emacs, not Spacemacs, not Doom. They're then greeted by an unfriendly UI and confusing commands and dammit it doesn't even autocomplete JavaScript by default.
Dark color schemes and proper right click functionality might seen dumb, but they're one easy step towards making emacs seem like an editor for the 21st century and not something your dad used on a Lisp machine in the 80's.
I recently had the experience of a friend of mine, a data scientist, tell me he tried to use emacs but just couldn’t get it to work. When I asked how he installed it, he was like “well I just downloaded it, and started tinkering a bit with my config”. After which he just ditched it, he accepted that the learning curve was just to steep.
The idea that there are these whole starter packs never crossed his mind. I referred him to a few, and he suddenly got much more productive and has been a happy emacs user ever since.
Moral of the story: at the very least, users should be made aware of these starter packs much more prominently when downloading or installing emacs. Alternatively, fix the defaults.
Completely agree that out-of-the-box Emacs experience is NOT where it's at. I have twenty years invested in tweaking it to minimize keystrokes and operate faster for my use cases. Just remember that Emacs is not actually an editor, it's a Lisp Machine OS you can use to build an editor out of parts
Also keep in mind that alternate distros like Spacemacs are the way Emacs has to evolve, because making drastic structural changes to defaults would break so many user scripts and packages -- the things that provide most of the long-term value proposition of using Emacs in the first place.
There's support for language servers (and I consider the existence of LSP to be a new hope for Emacs and Vim to stay relevant in the future), but it's arguably so-so.
As good as the Emacs community is, it still has pretty limited amount of time and manpower to throw at problems. I feel the wider development world starts to outpace this capacity.
I’m really curious what you mean by that, and how you see the world evolving such that Emacs, as is, won’t be able to come along with it.
[0] https://www.destroyallsoftware.com/talks/a-whole-new-world
An interesting thing that often gets forgotten or missed is that Emacs doesn't depend on a conventional TTY to run. It's already capable of displaying images either in separate buffers or inline.
From Gary's talk there, my thoughts would be that a number of the features he's put in there would:
a) be potentially better-served as CLI tools instead of baked directly into the IDE, with well-defined inputs and outputs. I have no problem imagining use cases for e.g. the crash navigation stuff outside of an editor (perhaps as part of an error-handling dashboard).
b) likely already be possible to build in non-terminal versions of Emacs, without having to design your own terminal and editor from scratch.
By no means do I think Emacs is a perfect editor, but I'm also very cautious when pondering "do we rebuild from scratch"-type questions. I'm always keeping my eye on other editors and IDEs, and with varying levels of difficulty, I haven't really come across too many useful things that wouldn't be possible to do within the current Emacs/Elisp environment. Awkward, maybe.
It’s not that people are suggesting emacs tries to be everything to everyone; heck, by pure virtue of its extensibility, emacs is actually the one editor that could potentially be everything to everyone. But a simple startup screen, “hey, it looks like this is your first time using emacs. what kind of defaults would you like?” would do wonders and existing users would be entirely unaffected.
Automating the Starter-Pack-Installation at virgin start and adding one or two out of the box would be better. Many people are not downloading emacs directly. On Linux you go through your destribution.
I think the middle ground during the transition would be the worst of both worlds and there is no shame to no longer be on the top if the times change.
I don't think this is true. In fact, I think most people that start in Emacs do so because they've heard that old experts use it, and know they will have to put some effort in to understand why.
I started using Emacs ~2008 and it's longevity has been a major factor in my decision, as I thought it would likely be usable for the next 30 years as well and help me to avoid changing environments every few years with each new hype.
Later I found a talk which expresses the same sentiment in it's title: "The Editor of a Lifetime" https://www.youtube.com/watch?v=VADudzQGvU8&t=1823s
I've tried Spacemacs and it's pretty nice. Using it in vi-mode, it provides multicursors that are far more advanced than in any other editor I know. Also it has a sidebar.
On the other hand for me Spacemacs is pretty buggy (macOS + Linux), I sometimes have to redo commands. Some important vim shortcuts are not implemented and the sidebar is also not always working as it should. Therefore I refrain from adding more plugins to the mix.
Experienced Emacs tend to not use the Spacemacs theme and are working with solid configurations. Maybe a rock-solid default configuration would work.
A rock solid default config made out of Doom emacs might work.
https://github.com/hlissner/doom-emacs/blob/a2a5038b970df20e...
"Doom doesn't support `customize' and it never will. It's a clumsy interface"
I find the Customize interface very useful.
Bad idea.
Is it? What area are you in? In my hobbyist, college, and industry experience I've never seen anyone use emacs for anything. I have seen Vim (or at least vim bindings) a few times, but I only know of emacs from older unix discussions online.
Edit: Looking through stack overflow developer surveys, emacs use is in 16th place for editor popularity at ~4.5% usage, but has stayed close to that number for years.
But the short summary is that most people use it for the various functions an IDE provides. The major difference between Emcs and other IDEs (VSCode, IntelliJ, ...) is that (a) it's often a little harder to get functionality that is provided out-of-the-box by another IDE, but (b) it's much easier (in some cases, infinitely easier) to implement workflows or functionality not already implemented by said IDE.
As an example, I often run snippets of code and want to insert the result directly beneath the code in question (similar to Jupyter in Python, but for any language, in plain text, directly in my editor). A trivial amount of Emacs Lisp gave me that with minimal effort.
If you like to have nearly absolute control of your editing experience, Emacs might be interesting to you. For most people starting out, who just want to get hacking on some code as quickly as possible, it is perhaps not the best fit.
- 2019: https://insights.stackoverflow.com/survey/2019#development-e...
- 2018: https://insights.stackoverflow.com/survey/2018#development-e...
- 2017: https://insights.stackoverflow.com/survey/2017#technology-_-...
- 2016: https://insights.stackoverflow.com/survey/2016#technology-de...
- 2015: https://insights.stackoverflow.com/survey/2015#tech-editor
What's really amazing is vscode just appearing out of nowhere (7% in 2016, 35% in 2018). Blindsiding everyone. Cross platform, excellent to good enough UI/UX (very much inspired by Sublime Text but free), easily extensible in a widely available (and widely taught) language. For better or for worse.
Never understood why other editors, like ST, didn't give more UI options (checkboxes, buttons, dropdowns, a canvas, etc) to plugin authors. Consider how clunky a lot of plugin interactions with limited UI widgets available to them are.
But even if other editors started giving more freedom to design your plugin with more widgets etc, they could never beat the freedom HTML/CSS gives.
The second huge advantage of VSC: Microsoft behind it updating it non-stop. TextMate stalled, ST seems abandoned for long stretches of time (and it's not like we "already solved code-editing, what more you want") because of lack of manpower, etc.
The third advantage of VSC: first-class support for plugins, with "package manager" and storage built-in: plugin discovery, install, uninstall, enable/disable, configure, are all a click away. ST has this too, but not as refined as VSC, but more like a tacked-on text-based experience.
Two more advantages of VSC:
- remote development tools (MS). Code in your laptop, run/debug in SSH/Docker/WSL environment.
- automatically saved/synced preferences. This came in in this release.
I'm not in favor of Electron apps over native. But VSC is really that good.
The issue I had with Emacs is that while could get it to do anything, often it took a lot of time. I would often end up spending an entire afternoon or Sunday tinkering with my config to get set up to develop in a new language. Whe I adopted VSCode it took about 20 minutes - install a plug in, set some config. I had a better setup for Elixir in a text editor I had never used before in minutes, after having spend hours achieving an inferior result in Emacs.
The reason for this basically comes down to abstraction levels in a couple of places.
Language support in VSCode is at the 'plugin' level whereas in emacs you usually have to assemble several pieces. Partly this is achievable because VSCode made their own life easy pushing the hard work of language support out using the language protocol. Its widespread adoption in a relatively short time is a great benefit to everyone (emacs included).
That said the only reason I use VSCode instead of Vin is when I program in Typescript because the support is outstanding, always cutting edge, and super easy to set up. Code is ideal for frontend js programming in general with lower investment.
Similar to how awesome Emacs was for Clojure and Lisps in general.
But nothing will peel me away from (neo)Vim for generally everything else. I love how fast, portable, and perfectly customized I’ve made it over the years.
The difference with vim vs emacs vs VSCode is probably like the value with the community size and plug-in support. Just like programming languages become great through having great libraries and frameworks and tutorials etc, being popular has tons of value. After simply being good at all the foundational stuff.
The same is true for emacs, or vim or any other extendable editor. Poor code behaves bad everywhere.
But the real surprise is, VS Code usual performance is equal or better than emacs even with an average setup which is still a tad more powerful than whatever emacs offers on a good setup.
(I don’t mean this as a critique of VSCode. I have never used it.)
I mean, to each their own. Someone else using an editor I dislike doesn’t harm me in any way. But if someone told me that VS Code was “best in class” for anything other than a language I have never touched and have no knowledge of, I’d look at them like they’d just asserted that the sky is green.
To connect this a bit back to emacs, I think the big contribution VSC has made is to popularize the language-server concept, which decouples the UI from the automagical autocomplete and context-sensitive documentation we expect from IDEs.
Emacs's lsp-mode and (I'm told, not yet tried) eglot make it possible to use emacs to productively write java, something I won't attempt without tooling support.
The LSP interface, like slime, enables a whole class of interaction, rather than re-implementing the language support for each languge, like in days of yore.
That truly is a modern coding practice, brought to emacs.
Hardly seen outside first world countries, and even on Europe it isn't easily spot outside the rich EU countries.
I did a couple of consulting gigs where the only iMac available for the Dev teams was used in turns for iOS deployments, for applications done in cross platform frameworks, where 90% of development time was spent in Ubuntu and Windows based computers.
It is possible that "Stack Overflow surveys" select for programmers who tend not to use Emacs. For example, I use Emacs regularly and know what Stack Overflow is, but have never taken one of these surveys.
I'm not even sure how they survey developers. Ask on some crufty mailing list and you probably will get a completely different distribution from the one they showed.
(On a side rant, I really dislike how a lot of websites have normalized “create an account on a website” to mean “Sign up for receiving a plethora of emails about everything the website and its creators are up to these days”)
Hear, hear. If I get an email from a company whose newsletter I didn't sign up for, I immediately unsubscribe... but I really shouldn't have to.
You can do the same thing in Gmail with the +, but some websites filter those out or don't allow them.
Most "normal" people just used other "more visual" editors.
As I learned from the masters I started using more and more both vim for unix tasks and programming and emacs for lisp. Now I use 65%vim, 30% emacs, 5% other editors.
Both of those editors are extremely powerful. But you need to know how to use them. It is not painful for the master to use them, in fact it is automatic and instantaneous and faster than any other editor, a thought becomes an action without conscious intervention, like you thing in playing Do minor in an instrument and your fingers do it automatically, you want to erase a line or replace a word, you think on it, is done.
They are like musical instruments. You could have the best piano or violin in the world, if a mediocre player plays them, you get bad sound.
Most people would be better served with a simple electronic piano or a tablet with lights that point to the next notes of the song, and auto correct them when they play a bad note.
I guess the issue that is being handled here thought is that, just like the piano, the road for those actions to become unconscious is a long painful one.
When I started using Golang for work the first thing that I did was buy GoLand from jetbrains. It just works, and I'm paid for "playing piano", not for "learning how to play piano"
I wish I was able to use emacs professionally but until I'm able to dedicate (usually unpaid) time to learn it, it's just easier to use something else
Also I can move around in emacs and do stuff with macros that has saved me a lot of time. And emacs rarely has problems, unlike visual studio, which crashes occasionally and is permanently sending my dual-core to 100% of both.
Emacs refactoring, heh, not so good... So I use both, do main editing in emacs.
Really? I've always found emacs to be on the slower side of things (not nearly as bad as jetbrains / visual studio, of course) and many keyboard commands to be unnecessarily clunky. I don't know how many times I've given emacs a go, and yet I can't seem to get nearly as proficient as I am with VSCode (and sublimetext before that).
I know part of it is that I don't typically work in languages where having a live REPL up is terribly useful, so emacs support tends to be a bit... second class.
I think my biggest gripe is that there are actually two mountains to climb. First, you have to become proficient with emacs- the chords and so forth. Then you have to find the magical combination of plugins that work together on your operating system with the magical configuration that brings emacs up to par with things that I consider to be table stakes for a good development experience. Doom emacs probably got me the closest there, I think, but struggling to become moderately productive when I already have a tool with which I am extremely productive seems entirely pointless.
Some of the growth that Emacs has enjoyed over the past several years is from folks who want the Vim style modal editing in an editor as customizable and extensible as Emacs. Emacs "distributions" such as Doom and Spacemacs cater to these folks.
Any editor feels clunky for the first week of using it, Vim and Emacs most of all. Nobody wastes the headspace in staying current on multiple editors. So I don't know that you'll ever see an objective comparison of the two. But they're both solid ways to write code, it just takes way too long to get either one dialed in to do the things we expect modern editors to do out of the box, like code completion.
Things were very slow for a few days, and there was a lot of swearing, as I got weird results from hitting a wrong key. But after about a week I was able to get along adequately, and after another one, I was at the point where I was making choices for optimal methods without really thinking about whether typing 2w would be better than holding j for a while.
I think the key was that I made the switch during a vacation, when my workload was lower and I would not be so frustrated by learning enough that I could select between methods.
Learning either vim or emacs in a rush is not good because you are likely to become habitualized on a small subset of methods, and will be blocked from learning other methods that will increase your productivity some day.
Perhaps ironically, mac OS text input boxes are where I use most of the traditional emacs C-/M- keybindings these days.
I use vi-family editors for the same reason I use grep: it’s installed everywhere. I’m not religious about its benefits.
Later on I had to work with a number of different versions of different UNIX platforms on a daily basis (Tru64, Solaris, HP-UX, AIX) as well as multiple varieties of Linux, and vi was a common denominator on all of them.
I've probably worked with 500 developers, if not more.
My personal impression is that Emacs is like the Yeti of programming editors. Everybody has heard about it, few claim to have seen it and even fewer still can claim to have proof of the sighting :-)
I already wrote this to another comment, but quoting myself:
> Is this a USA vs the rest thing? I've worked in many startups in the US and almost everyone uses emacs. Last few years, VSCode has been getting popular though. I had a similar experience when I was a student in UC Berkeley, although it seems like there were more vim users in school than in industry. Anyway, pretty much all my current coworkers use Emacs and I work in Boston, MA.
> Personally: I cannot imagine programming without emacs, to me programming is so strongly associated with emacs...
> Of course, I also understand that it's all personal preference.
I don't know if there is a way to prove that I'm lying. :)
I haven't even used emacs in years so I don't even know anyone that uses it; I stick almost exclusively to Vim (and for 8 months this was my only "IDE"), PyCharm, and WebStorm.
Unless it’s an emacs related conference you will rarely see emacs being used as an editor. You will see a few VIM users sprinkled around. But if it’s a recent conference the vast majority are gonna be VSCode users.
Also, Berkeley as in BSD.
You're probably living in a smaller bubble than mine :-)
- I write software with unit tests. I have a custom method bound to Shift-F5 that computes the test file associated with the current code file, and switches to the buffer.
- I have a similar method bound to F5 that runs the tests for the current file (code file or test file). Ctrl-F5 to run the previous test again even if you're in a different buffer.
- These are configured for multiple programming languages, testrunners, and different conventions within specific programming languages, in different parts of the codebase.
- Test output goes to a first-class buffer, like any other file I'm working on. If I want to do something like `git blame` the file I'm working in, it's also a first-class buffer. Want to run a shell? `tail -f` some logs? All in first-class buffers.
- Why does it matter that things end up in first class buffers? Well, there's lots of random goodies like `meta-x json-pretty-print-region`, so if your execution dumps a blob of unformatted JSON or whatever, you can manipulate it readily. (Tab complete is available on these commands.)
- Autoformat your code automatically with a save hook. Autoformat it on your own schedule by calling something like `m-x blacken-buffer`. I don't think vi does as good a job of manipulating the contents of your file with internal and external programs.
- undo-tree-visualize.
I don't think the things you describe are the differentiators for the Great Editors. For me it's more their phylosophies that make them stand apart: despite the wide usage, vimscript is far more clunky, narrow-scoped and less powerful than elisp. Which means that stitching together something complex is hard and awkward in vim. Emacs is far more suited for complex processing due it's nature of a lisp machine. The chords are awkward though. So, "emacs is a good OS, but it lacks a good text editor".
I would love to see that: everyone I know who uses Vim ends up typing out test names in a separate terminal, or running some sort of a shell-out command that suspends editing of the current file until it is complete, and then hides its output.
It seems like I spend a fair amount of time mosh/tmux to remote servers and I like copying over my Emacs configuration, be up and running. Same for users of vi or vim.
VSCode has good remote server development support also, so there are great options to keep most people happy.
For your anecdata collection.
Most of the other languages you listed have extremely poor Emacs integration, both for cultural reasons (C# devs tended to be on Windows), and because some of those languages are so dominated by other IDEs that nobody bothered to write a good emacs extension. Java is a great example of this; the IntelliJ experience in Java is just so good, nobody managed to come anywhere close in Emacs, which created a self reinforcing cycle.
JDEE (http://jdee.sourceforge.net/) exists, but even I give up on Emacs when I want to write a lot of Java (and I use Emacs for literally everything else, including JS).
The intellisense is amazing too. Start typing a method name and you see arguments with type annotations. it's overkill for scripting, but working on tangled legacy code it's very helpful.
Personally: I cannot imagine programming without emacs, to me programming is so strongly associated with emacs...
Of course, I also understand that it's all personal preference.
And, to be honest, I can't exactly blame them. I tried setting up Calva the other day, just to experiment, and its out-of-the-box experience was far better than emacs'. It was literally just a matter of installing the extension and loading a Clojure project (I was using Leiningen for my project definition, but Calva supports others as well). It brought up a REPL, it started doing autocomplete, and you could even hover over symbols to view their documentation. And none of this required any kind of manual configuration on the part of the user.
At this point, I honestly can't really recommend emacs to any developer who doesn't already know how to use emacs. If you want to start programming, just download VSCode and get the plugins for your favorite language.
Mine isn't either and I find it hard to imagine owning a computer (or using git beyond the very basic operations) without having access to emacs, but it does seem likely that coworkers won't have completely independent text editor preferences. I would expect to see more VS and VSCode in the Redmond, WA area, even at places that aren't Microsoft.
Others claim the opposite. Maybe the contradiction is explained by the hiring culture. Startups with emacs users hire more emacs users. Not that they would make emacs usage an explicit criterion or even ask such interview question. But probably there are some properties over-represented in 4% (or whatever the figure is) of programmers that are emacs users.
Disclaimer: Part-time emacs user since 1986 or so, full-time emacs user since 1989. Should spend some time to learn the newer features / customize it in a more compatible way with the rest of my software. I am lazy to make "another" editor as Stallman puts it even if I like Lisp hacking occasionally, but I would happily switch to a modernized configuration if it were available upstream.
There have always been popular tools. Most of them haven't stuck around though.
Emacs has.
I wouldn't recommend using it right away though. Instead, I'd recommended accumulating some pain by using other popular editor-like,workflow-like,manipulation-like tools, because that might be the only way to appreciate what Emacs brings to the table.
(though I have to acknowledge VSCode's achievement, gaining massive adoption in what has always been a fragmented space)
[0] http://www.cse.chalmers.se/edu/year/2017/course/DAT350/
[1] https://wiki.portal.chalmers.se/agda/pmwiki.php
[2] https://agda.readthedocs.io/en/latest/tools/emacs-mode.html
I've used Emacs for years for editing/programming, running shells and reading news/email.
I've attended two universities in the UK and it was used by default for some of their programming/computational courses; this was in different departments (Physics and CS), a decade apart.
Emacs has been used to build user interfaces (e.g. ProofGeneral, which was the de facto interface for theorem provers like Coq and Isabelle for many years).
Some programming languages de-facto assume they're being written via their Emacs mode (notable Agda; similar to how some JVM languages assume they're being written in Eclipse or IntelliJ).
Years ago I inherited an academic research project which happened to be written entirely in Emacs Lisp.
If one looks at computer history there seem to be several versions of a cycle that looks like “crap underpowered computer slowly gets more features and better performance only to become outnumbered by a smaller slower cheaper computer.” Depending on where one fell in that cycle, emacs may not have been an option (eg if you were starting programming on dos or an early windows you likely wouldn’t be using emacs. If you were starting at the same time using a Unix workstation, emacs might be a reasonable or recommended choice).
During the early naughties you were probably using windows and not exposed to emacs unless you worked on Unix/Linux based web backends.
I'm probably in the minority since, despite a decade-plus of use, I'm by no means a power user. I use a little bit of org-mode and babel here and there. I can hack around in elisp if I want to tweak a mode. But that's about it. To be honest, I don't even compile code or navigate the directory tree from inside emacs.
That being said, two reasons I don't think I'll ever switch. One, the key bindings and commands just feel more elegant. Don't know if that's because they're locked into my muscle memory, or they're genuinely better. Two is that I live in the terminal. IDEs are great, but I much prefer just piping find to grep to sed or similar bash-fu, when I need to do something fancy.
- Former physicist turned programmer
This is how incumbents die: when the fact that something has existed for a long time is taken as proof of it being at no risk of disappearing.
I used to work for a company that has been around for roughly 150 years. And it is precisely the attitude that "we've been around for 150 years" that made it blind to the fact that in the last 15 years, it has become a little bit less relevant every year because disruptors slowly eats away its market. In one sector the company would boast 3% growth year over year - while glossing over the fact that the sector had a growth of several hundred percent per year. You can have growth and at the same time lose market share at an astonishing rate.
This is kind of what happened to Emacs. There has been an astonishing growth in the number of developers over the past decades. Which means the "market" for editors and IDEs has exploded. And while more people may be using Emacs today than ever before, I would hazard a guess that the market share has gone down.
I agree that those cosmetic changes won't modernize Emacs in a meaningful way since it is a very low bar. I also think the article is correct in pointing out that discoverability needs to be addressed. Contrast Emacs and VS Code in terms of extensions. Both editors are intended to be extended. VS Code does a good job of highlighting extensions, while the Emacs extension manager is buried. Likewise, Org seems to be rather popular yet very people will discover it independently since the user interface isn't designed for that.
That said, some of the discussion about discoverability was disheartening. Telling people about features isn't really sufficient. They need to be exposed to it while they are working with the program, and that exposure has to be in a non-disruptive way. Tutorials, video or otherwise, aren't going to help because of that. There are plenty of Emacs tutorials online anyhow.
If the LWN article is an accurate reflection of the discussions, I think that Emacs developers have to put a lot more thought into how to progress.
I guess I agree that ibuffer should be part of the standard distribution. Less sure about undo-tree, but could be an option if the authors released it under appropriate licenses (I understand that contributing code to Emacs is somewhat cumbersome; although if I were smart enough to do so, I would jump through the hoops in a heartbeart).
Emacs has a steep learning curve and that's good. You need a moat to keep the barbarians from destroying your kingdom.
That's probably how most VS Code users feel about learning Emacs after reading about it on HN :)
For people who have used $EDITOR for 20+ years there's little incentive to change to something else, but if you want to bring in fresh eyes to your project so that there'll be enough people around in another 20 years to maintain the whole thing it behoves you to think about attracting those people.
Sane defaults and being more approachable is a good way to do that.
Does emacs even offer anything like `vimtutor`?
https://i.stack.imgur.com/egD8V.jpg
That is the splash page that hasn't changed much since 2000. Reading the helpfully highlighted first menu entry do you think that Emacs has a tutorial?
Users who can't even be bothered to read the text in front of them are not an asset to a project that doesn't charge them, they are a liability since they force the project in stupid directions. The death of firefox is a perfect example.
The thing that Emacs should focus on the future is true concurrency. Nice to haves would be a non-gtk gui, adding scheme scripting support and releasing a space cadet mechanical keyboard.
Here's someone recreating the Space Cadet keyboard key caps -- i.e. the plastic covers for the keys, not the actual keyboard. This is a more modern profile (key shape), rectangular/cylindrical similar to modern keyboards rather than the spherical top of the key like in the 1970s and 1980s.
It might give you an idea how expensive a custom keyboard would be.
https://www.reddit.com/r/MechGroupBuys/comments/j3pmmn/gb_gm...
The mechanical keyboard community will probably get there first.
From a quick search, I've found this [1], which goes a bit beyond the original Space Cadet keyboard.
Yup. And iirc it's more discoverable than vimtutor because it's on the first page of the vanilla Emacs
While preconfigured Spacemacs, Doom and others are doing a good job in turning emacs into OOB editor, they still require some tinkering with lisp, while in vscode you just install plugins and you are done.
Most of the emacs community radiates that same attitude, which is one reason it stays where it is and doesn't flourish.
Emacs is in that unfortunate position that you can learn the shortcuts and 'use' it for months before you even see your first bracket and end up thinking the brackets are the problem, not you.
The number of times I've heard people demand the scripting language change to python...
Someone that thin skinned would demand that the project accommodate them, try to take it over and then run it to the ground.
After all it's not like Stallman didn't become homeless because of people like that.
For comparison of numbers and growth rate: VS Code was new in April 2015, had a claimed 2.6 Million active monthly users in Nov 2017[1], became the most popular editor in StackOverflow's user survey in 2018[2] with 34% of respondants and again in 2019 with 50% of respondants, to a claimed 11 million users in 2020[3]. Its codebase has been forked 16,000 times[4].
In 5 years, VS Code has gained more users than the population of Switzerland, than the population of London, than Uber has drivers. I'm not suggesting Emacs ought to chase maximum popularity, but if there was any feeling that "the editor / IDE market was saturated" or "there was no demand for editors", that doesn't seem accurate.
[1] https://vscode-eastus.azurewebsites.net/blogs/2017/11/16/con... - (VS Code has telemetry built in, so Microsoft has some accurate idea of numbers, even if they still have the incentive to hype them up a bit).
[2] https://en.wikipedia.org/wiki/Visual_Studio_Code#Reception
[3] https://code.visualstudio.com/blogs/2020/06/09/go-extension
You don't mean "modernization". You mean "without it changing". And the answer is yes, it will die out.
Most of the time when I try to get people to adopt emacs, they abandon it because it feels like a huge task to relearn basic text manipulation. They never get to actually see what makes emacs good because they don't feel compelled to get past the initial bump.
You have to put in some amount of effort before you get its benefits. While I certainly don't mind making simple things easier (e.g. CUA mode), I also see that doing so will not help new users much beyond doing very basic editing.[1] There are a fair number of stairs to climb to get to the point of being useful, and superficial stuff like CUA, etc simply eliminate perhaps 5% of the steps. Don't expect this change to make a big difference in retention.
As a corollary: If someone is not willing to learn how to enable CUA mode in the config file, then it is highly unlikely they will ever learn to use the features that make Emacs salient.
[1] I know, because my first decade of Emacs use was like this. I got past CUA mode, but otherwise used it for very basic editing. I always installed an IDE to do "real" work. It's only after one of my favorite IDEs died did I decide I really should just learn to use Emacs properly, and invested a week's worth of effort to be proficient in it. That week made all the difference.
I think that’s uncharitable. For a newbie low on confidence it’s often death by a thousand (paper) cuts: CUA mode, Surprising undo model, How to download packages, How do I enable fringes/margins, Windows-vs-frames, etc.
Each small change has a cognitive tax, and allowing users to feel psychologically comfortable and add tweaks slowly will make the learning curve much gentler.
I wouldn’t be surprised if the strongest indicator of whether someone sticks with Emacs is whether they have access to an Emacs expert with whom, or a community where, they feel comfortable being a newbie.
A lot of benefits of Emacs you get are when you realize you are operating a lisp VM. Enabling all the same things that other editors do in the same way will not suddenly make them choose Emacs. Someone needs to nudge them towards the good parts of emacs/show a powerful application that will make them use it.
I tend to get surprised by this complaint - especially in the article where undo-tree was recommended as an alternative.
Both the Emacs undo and undo-tree are "surprising" models in that very few standard editors support anything beyond the most basics. Personally, I've not had trouble with Emacs's undo (beyond it not visualizing it). Switching to undo-tree may be OK, but it's still surprising. Switching to the standard one in most editors is a pretty serious regression.
> How to download packages
Once I properly learned Emacs, I did not have a need to do this for the first few years. I'm not referring to decades ago, but the 2010's. While I agree that a convenient way to download things from MELPA would be nice, I hardly see not having it as a barrier. Most people new to, say, Visual Studio don't start with "How do I download plugins". And once you know some of Emacs basics, package downloading is but 2-3 lines in the config file and a keybinding that presents you a menu.
> How do I enable fringes/margins
Again, I don't see this as a beginner feature. I don't know how to do this, and I've never wondered about it - both as a beginner and as an advanced user. I've use Visual Studio quite a bit and never tried to enable/disable them there either. I don't think this is something a typical beginner would deal with.
> Windows-vs-frames
What is the issue beyond terminology? It wouldn't bother me if we rename these. I don't see a great enhancement, though.
> Each small change has a cognitive tax, and allowing users to feel psychologically comfortable and add tweaks slowly will make the learning curve much gentler.
Although I personally don't recommend it, but have you heard of Customize in Emacs? It used to be (and may still be) the recommended way to change config options. It has help on various options, and is an interface - not "edit config file with Elisp commands". Many users say it really helped them and certainly flattened the learning curve.
> I wouldn’t be surprised if the strongest indicator of whether someone sticks with Emacs is whether they have access to an Emacs expert with whom, or a community where, they feel comfortable being a newbie.
I did not have access to an expert. I simply read a book on it[1], and the rest was from occasional Google searches. In those days there really wasn't that much friendly info online, but it was enough to maintain the momentum. There is a ton more stuff these days to help beginners. Not to mention Youtube videos.
(BTW, as a reference point, I was a power Emacs user for almost a decade before I learned enough Emacs Lisp to write a simple loop - too many people have the misconception that one needs to know elisp to use Emacs well).
As someone commented on HN in an earlier submission: Who becomes a power user of anything without reading manuals? That it's not straightforward to do simple text editing in Emacs is a fair criticism[2], but also a bit of a shallow one. There are plenty of friendly text editors for simple text editing. Let people use them! The value proposition of Emacs is in its powerful capabilities, not basic text editing. It's a bit like complaining that Ferraris are a pain to learn to use when all you will do with it is grocery shopping. Just use a regular car!
[1] This was the norm in the pre-Internet days (80's and 90's), BTW. Even in the 00's when interfaces were nicer, the people I knew who were power Visual Studio users became so by reading books or online manuals - not by random discovery or random Internet pages.
[2] It's ironic that I write this, given that the only reason I began using Emacs is that the other option people led me to (vi) was even harder to do basic text editing. At least with Emacs, I could type and it behaved like most editors I'd been accustomed to in DOS. With vi I was immediately confronted with command/insert dichotomy, not being able to edit prior to the insertion point, etc.
It's also amusing that people complain about Emacs not being like "normal" editors, and folks invoke Stack Overflow polls to indicate its lack of popularity, and yet vim is used by a quarter of SO users and is ranked 5th. vim is also beginner hostile, so the beginner hostility really isn't the reason for Emacs's low usage.
> While I agree that a convenient way to download things from MELPA would be nice, I hardly see not having it as a barrier. Most people new to, say, Visual Studio don't start with "How do I download plugins".
I think this statement is untethered from reality, and matches approximately zero people I know. Almost everyone using a text editor is using it for purposes which would definitely be helped by task-specific enhancements (plugins which are typically much easier to get in other editors/IDEs)
> I did not have access to an expert. I simply read a book on it [...] given that the only reason I began using Emacs is that the other option people led me to (vi) was even harder to do basic text editing.
Yes, and the fact of the matter is that today people have many editor options which are very powerful and also have a much friendlier learning curve.
Note that I'm referring to Visual Studio, not VS Code.
In my last job, we didn't use any plugins with Visual Studio for a bunch of years before one developer convinced the rest to use Resharper.
> Almost everyone using a text editor is using it for purposes which would definitely be helped by task-specific enhancements (plugins which are typically much easier to get in other editors/IDEs)
I find this statement untethered from reality. I think this gets to the crux of much of this discussion. There seems to be an implicit assumption that Emacs exist for writing code (hence the comparisons with VS Code, etc).
I think if you poll most Emacs users, while programming will definitely have more weight, a lot of people use Emacs for all kinds of things unrelated to programming: TODO management, document authoring, writing emails, etc. Most of my Emacs usage in my first job was simply editing text files, not programming. This is in line with most non-SW engineering jobs: They need text editors, but not plugins. Over 95% of my home usage is non-programming related.
So when you imply almost everyone using a text editor is using it for purposes where they will want to look for plugins, that's simply far from the truth. Until recently, most people who used text editors used Notepad (the default Windows one), and I've never managed to convince a Notepad user to use anything more powerful. Nice plugins would not sway them.
While Emacs is heavily used by some programmers, I do not think it is the aim of Emacs. It is a general purpose text editor, and a platform for writing text oriented apps.
Those still need addons/plugins like org, mu4e or some other mail client, etc. This my point — not just a vanilla text editor.
If you load a (for example) Java file, a little popup appears saying "Hey, do you want me to download the default Java plugin". Now I can imagine Emacs would find it incredibly hard to pick a "default" plugin to offer users, but it is super helpful to get started.
I have, I've tried it, and it's terrible compared to virtually any other editor's equivalent for editing preferences/settings. It's super hard to navigate and search, it's difficult to figure out the terminology if you don't already know it, it's unclear how various settings affect one another, and IIRC it can actually make changes to your configuration file that conflict with editing it in any other way. To be fair, I am not a regular Emacs user, but getting sucked into the insanely frustrating tar pit of Customize made Emacs seem far more inscrutable to me for years.
If I could suggest just one change to make Emacs feel more "modern," it would be to entirely redo the Customize section to make it behave more like VS Code's preference system: one single page with collapsible headings, clear descriptions, and perhaps a super-top-level "behavior" control that makes batch changes to make Emacs more comfortable for users coming from different editors (e.g., choosing between a Canonical Emacs mode, Vim mode, or CUA mode). It doesn't have to try to cover every possible setting -- just hit the top several dozen and then say "for everything else, there's Lisp".
> Vim is also beginner hostile, so the beginner hostility really isn't the reason for Emacs's low usage.
This strikes me as half-correct, as someone who's made serious attempts with both of these editors. They're both difficult for beginners to get used to, but once you get over the initial learning hump, Vim was always much easier for me to tweak and configure. That may sound nuts, but editing .vimrc feels like editing an INI file, and at least in my experience, Vim's plugins are much better behaved when it comes to not stomping on one another. Every attempt I've made at getting serious with Emacs has ended in spending hours trying to get two or three extensions I want to use to play nicely with each other; with Vim (or VS Code), this almost never happens.
I've long suspected Emacs's greatest strength is also its greatest liability: you can do almost anything with it if you learn Emacs Lisp, but it often feels like you must learn Emacs Lisp to do almost anything with it.
> Most people new to, say, Visual Studio don't start with "How do I download plugins".
Not to pile on with the other reply, but, well: editors like Visual Studio Code, Atom, Panic's new Mac-only editor Nova, and even Sublime Text to a degree actually make plugins front and center. It's a very different approach than what Emacs and Vim have historically taken, but I think it's contributed greatly to their mindshare. VS Code in particular goes out of its way to recommend plugins to you based on the files that you've recently edited.
It's probably not hard for someone to do that with Emacs - all the bits and pieces are there. I wouldn't be opposed to this.
> They're both difficult for beginners to get used to, but once you get over the initial learning hump, Vim was always much easier for me to tweak and configure.
At the risk of starting a pointless war, I suspect it may be because Vim just has an order of magnitude fewer features than Emacs does. Many people have wanted Org mode in Vim, and no one has been able to make a good one.
> when it comes to not stomping on one another. Every attempt I've made at getting serious with Emacs has ended in spending hours trying to get two or three extensions I want to use to play nicely with each other
I believe you because this complaint does come up from time to time. I must have been simply lucky that this has been a very rare problem for me. In fact, I often tell people Emacs is great because one can take disparate packages and use them together to get powerful features. To me it exemplifies the UNIX philosophy of combining tools better than most UNIX utilities themselves do. The worst I've encountered is a conflicting keybinding.
> you can do almost anything with it if you learn Emacs Lisp, but it often feels like you must learn Emacs Lisp to do almost anything with it.
I view that as one of the biggest myths. I was a power user for about a decade before I learned to even write a loop in Emacs lisp. The most I knew was setting the value of variables. That's enough to be a power user.
Now that I know Emacs lisp, I don't have a burst of productivity compared to when I was ignorant. I've customized to solve a few annoying problems, but I've not had any moments of "Oh man, I wish I knew how to do this all these years."
I don't encourage Emacs users to learn elisp. If I ranked things they should explore in Emacs, there would be a lot of stuff higher on that list than learning elisp (org-mode, etc).
I am not sure whether I just have bad luck with Emacs extensions. :) I suspect it depends on what languages you're delving into; I found trying to get HTML, CSS, PHP and JavaScript modes all playing nicely together (literally, since the same file could technically have all four, with a secondary template language thrown in for good measure!) challenging. But that particular adventure was a while ago. (My most recent attempt was with Spacemacs, which, uh, I'll just say it has some great color schemes.)
Re: Emacs Lisp: well, I did say "often feels like," not "actually is." :) I'm sure you're right; it's just that sense that a lot of early problems get solved by "to do the thing you want to do, paste this code into your init file," and getting past the feeling that you're assembling a configuration you don't reallllllly understand -- and thus may not be able to debug if something goes wrong -- can be a hurdle.
I don't doubt vim is very powerful for things like programming, but can I use it to automatically scan my emails for keywords and make TODOs out of them (in just a few lines of code)? Can I use vim to compute derivatives of math functions and automatically insert them into LaTeX documents? And so on.
Don't look at Emacs merely as a programming editor. It's a playground for anything textual.
Yes, VSCode will be replaced by something newer and flashier, but the learning curve to switch to it will be minimal.
It's a plugin management system that happens to be shipped with a set of plug-ins targeted at serving as an IDE, written in Java instead of Lisp.
Ah, but you miss its hackability aspect by virtue of being a lisp runtime. I wouldn't say eclipse is anywhere close to "hackable" as emacs is.
Just run C-x b <scratch> RET and you have an elisp buffer to manipulate the state of the entire editor. It allows for superfast iteration, compared to the plugin development cycle of other editors. Though, vscode/javascript has definitely made it much closer to what is possible in emacs.
IMHO, the barrier to entry for modification for both emacs and vim is much lower than their competition: evaluate text in a buffer, observe change to your editor
I don't know of any other tooling has that immediate feedback loop remeniscient of the old JS in HTML (or the dev tools console, as apples to apples) approachability
An exaggeration, but not a large one.
It’s quite silly to think that dark mode is a modern invention. It’s just a example of how software trends are a form of fashion, and they do behave cyclically.
See also: return to lightweight clients and fat servers as we moved onto the web, and then moving the bulk of work back to fat clients with React etc
Dark on light is at least thousands of years old, think of ink on papyrus in ancient Egypt.
My first computer could display dozens of colors, but defaulted to a dark background and light text. Windows 3.11 defaulted to black-on-white, on hardware from the same era. And now we're cycling back to defaulting to dark modes again.
It feels like a spring loaded bundle of magic that will explode if I look at it wrong, and, having exploded, I will never ever ever get it put back the way it was.
It's the assembly line worker that doesn't, and sticks to using the company-provided "industry standard" tooling. The assembly line worker doesn't need to make custom tools, because he/she has no agency - the worker's role is just to close a feedback loop in a well-defined industrial process of mass manufacturing a fully specified end product.
If the goal is to make furniture, or a glass flask, or a pair of socks -- why would you think those skills overlap with the skills required to improve a band saw, build a torch head, or manufacture knitting needles? They're not even using the same broad area of skill.
It is lucky that you can change software so easily, but I think calling anyone who doesn't feel it is a good use of their time to customize one tool instead of just using a different one an "assembly line worker" is quite insulting, mastering a tool doesn't necessarily require being able to manufacture it. I could not manufacture a pen but I'm pretty good at writing =P
I have a woodworker in my family and from what I observed watching him at work, he mods his tools for ergonomics, and if the piece he's working on is tricky to use with his machines, he constructs the necessary affordances to make it easier.
Similarly in programming, you won't get far if you only keep to what your IDE offers you out of the box. Configuring your IDE, writing scripts, writing software that automates your work - it's all part of the craft.
I also don't know why you'd draw any kind of line at "modified own tool". Building your own 3d printer doesn't make you creative if you're using a kit, it's the parts you make that are creative or not. Classify based on what someone is doing with the tools, not the tools themselves, that's just a cargo cult.
The point wasn't to draw a line between "programmers - craftsmen" and "programmers - assembly line workers", but to highlight that programming is very much craftsmanship, and because of that, I disagree with the thought "I am a craftsman, not a tool maker" in the comment I replied to. A craft is almost by definition something that isn't streamlined to the point you can reasonably only focus on using tools you're provided. There's always a benefit in doing meta-work - work to make your work easier. This applies to programming much more than other crafts, because the skill set you need to build tools is literally the same as the one you use for working with those tools.
Also note that the comment didn't say the assembly line workers aren't creative (though on a perfect assembly line they can't be creative at work, by definition) - but that the type of work doesn't leave much space for bottom-up improvement.
> Building your own 3d printer doesn't make you creative if you're using a kit, it's the parts you make that are creative or not.
If building your own 3D printer lets you shorten your iterations compared to your old process of sending CAD drawings to some company and waiting a couple of days, thus saving you effort and money, then building that printer from a kit is very much worthwhile and it's what I'd expect a craftsman would do. Too much focus on the work immediately in front of you is bad too (see also: greedy algorithms). This whole topic isn't an issue of creativity, but pragmatism.
If you really aim for a modern Emacs, then forking it and fixing it from the ground up might be not the worst idea longterm.
Emacs is so old that it has accumulated quite a number of old cruft and debt.
But some things make emacs just a bad editor, even for people who did spend the time to learn it. For example emacs is horrible at dealing with big files. The entire editor is stuck for seconds if you open a log file with just a few megabytes of content. Emacs performances are also really bad when compared to other editors, simple syntax highlighting or intellisense is just really, really slow.
I used emacs for years as my main editor because I was happy to have something stable, because I love lisp, and because I really like the introspection and control you get. But at some point I realized how fast and way more advanced other editors were in comparison to what I could get with a tuned emacs environment and jumped ship.
Even keeping the emacs UI and UX there is a lot of modernization that can be done under the hood to make it up to the task of the modern world.
Something like spacemacs and prelude would have a much wider adoption if there was a mode that can be enabled to make the learning curve smaller, the look / themes better, ui more intuitive.
Unpopular opinion: we should write the "new" Emacs in Julia (and maybe Rust).
Julia is a thinly disguised Lisp, offering all the wizardry associated with that language family - so it's very expressive.
Define success.
> But I think the bar is much higher than this.
Sometimes it's the small details who have the biggest impact.
Just not on your lifetime.
It doesn't have widgets, decent rendering engine with scene graph and hardware accel, it's single threaded, the language is clunky. You really can't make decent applications in emacs, only text with embedded images and primitive buttons, that blocks and stalls all the time.
It really needs some major update.
Software engineering and hardware advanced a lot in the previous 40 years in all the directions: PLs, GC algorithms, UI rendering.
If Emacs wouldn't be a contemporary technology, people would simply choose another editor.
oh, and a thin sans-serif font.
maybe a soundtrack
Emacs is one of the most successful text editors of all time if not the most successful. It is widely used for a staggering array of tasks.
It is over 40 years old.
When I see a highly successful 40+ year old piece of software, my first instinct isn’t to ask what the people behind it can learn from me but what I can learn from them.
I’m not saying the editor can not be improved. But I think the bar is much higher than this. It’s not an insult to say something like emacs is not “modern.” Of course it’s not. And changing the colors? The shortcuts that have worked for decades? Please.
If someone thinks emacs will be more successful with these cosmetic changes they are welcome to fork it since this is one of the earliest open source programs. Code talks, a bunch of people opining on a mailing list is pretty worthless in comparison.