That joke seems to imply a perfect understanding that it's more than a text editor. It is, however, referred to as "The Emacs Editor" in its documentation and "an extensible, customizable, free/libre text editor — and more" on its official website, which could lead to some confusion about its primary purpose if that's not editing text. I do begrudgingly use Emacs as my main editor because that's what the communities of the languages I like use, but I do find the editing experience to be sub-par compared to other editors I've worked with, and I find that there are better external alternatives to any of the common elisp applications, barring org-mode.
I just wish that things like autocomplete or debugging were easier to get right across languages...
Emacs being a platform within a platform is a feature. It comes with an extra benefit: it's a free (libre) platform. Completely shielded from corporate interests. There's no bullshit inside. No proprietary formats, no unnecessary network dependencies, no "X as a Service". Just a community of folks maintaining and expanding a parasitic OS that embraces interoperability and personal productivity above all.
Not many fellows are aware of the value of the freedom to use a platform and tools that are open, that give you the freedom to do what you want with it. They see a fancy interface, and they are sold, not seeing the long term costs, the loss of control, the crippled-ness, the trajectory of the whole industry towards a vision that takes away many forms of freedom that constituted personal computing as we know it.
There is even a decent editor application available these days in evil[0].
I've seen this thrown around when people joke why vim is better than Emacs and i think it's funny. But, seeing that Emacs has evil-mode, which is basically an implementation of vim on top of the said "operating system", i'd say it's false. Or ironic :D
Before using Emacs, I had always read that emacs has a steep learning curve. I found this not to be case since the vim emulation was so good and so complete, I was reasonably productive pretty quickly even though I obviously have a ton to learn about emacs.
How can this work? Let's say I am developing a spreadsheet. Each cell has a formula, and it has a rendered text version. How can this work in Emacs? I want there to be a "underlying" strongly typed version of the data which is rendered, but Emacs forces them to be the same.
Unix (with pipes) also works with plain bytes, but many pipes are not necessarily rendered. Given that emacs is inherently visual, because you see the buffer if you're working with it, why can't there be data structures?
Basically, your table is drawn as text (with Emacs automatically managing its layout, and providing various shortcuts for larger manipulations like inserting or swapping rows/columns). Formulas are recorded as text below the table. They get recomputed on demand, or can be made to recompute on each edit[1].
--
[0] - https://orgmode.org/worg/org-tutorials/org-spreadsheet-intro...
[1] - https://orgmode.org/org.html#Advanced-features describes a bunch of features, including recomputation of select rows on edit/navigation, as well as marking which rows are names of columns or cells vs. data.
I guess you could strong type by using a type cast formula with elisp...
SES is great as a quick & dirty spreadsheet. I also used it when I started "living" in emacs about 12 years back. I had SES worksheets for various things I'd often use Excel for. One was a stock tracker (downloaded data periodically form Yahoo! Finance), a tax estimator, a paystub tracker, a budget, leave tracker. Some were just worksheets for work problems (had a set of formulae and equations related to test cases, plug in numbers and determine what the expected output should be, or reverse it plug in received output and see what input should recreate it).
If you use org-mode, it has its own format for doing the same thing:
https://orgmode.org/worg/org-tutorials/org-spreadsheet-intro...
If I use emacs-as-a-spreadsheet, I tend to the latter anymore since I org-mode is my primary use of emacs anymore (with org-babel for editing source code).
I do not use Emacs as spreadsheet often. As my spreadsheet needs are larger than org-mode is comfortable with. Pretty much business people sharing data at work. But I have used for reports and whatnot and it's fine.
The main difference is that it chose javascript instead of lisp as its universal language, which, in the current world, is a much better choice for adoption.
Also, saying app can share data easily because the format is text buffer is either a tautology or a non-sequitur: not having a defined format can't be broken, sure, but it also cannot be reliably used. ask anyone who had to maintain bash/awk/perl labyrinthine assemblies...
That is not the main difference. The main difference is that Emacs can be extended on the fly. While VS follows the traditional plugin approach.
For VSCode to the have the same kind of extensibility it would have to allow opening an inspector on the _running_ instance. Click an element, jump to its source edit the source on the fly and have that change persisted. Or allowing your settings to patch (which by the nature of ES6 modules is not something you will be able to do).
The on the fly extension is crucial for quick QoL improvements to your workflow. You can spend 5 minutes writing a function instead of having to setup a project/plugin to something as trivial as say, copying a .env file and updating some values when you create a [git] worktree.
> Which is exactly the reason why... VSCode is winning the editors war.
The main reason why VSCode is 'winning' the 'editor' wars is because Microsoft is spending tons of money to build a great product. Emacs, vim, and other open source projects can't compete as they don't have nearly the same amount of resources. They have healthy communities and are thriving FLOSS communities but people who are scratching an itch won't be writing monthly tours of new features like https://code.visualstudio.com/updates/v1_52 f/e.
> ask anyone who had to maintain bash/awk/perl labyrinthine assemblies...
Text in Emacs is richer than plain-text. You have overlays to annotate it with metadata, text properties, you can attach callbacks to it, etc. It is only at the boundaries that you have to resort to plain-text for interoperability purposes.
This means it is easy to inter-op with CLI utils but present a richer, more powerful interface. Ej. dired uses ls.
It doesn't seem to be the main reason, otherwise how can you explain Sublime text popularity prior to VSCode?
That at best bifurcates the community (possibly along the age lines). I for one consider it to be a bad choice for me personally. JavaScript ain't a particularly pretty language. And it's nowhere as nice as Emacs Lisp.
> saying app can share data easily because the format is text buffer is either a tautology or a non-sequitur
I'd agree, though with caveat that an Emacs buffer is not just an array of text. It's an array of text with bells, whistles, and a semantically well-designed API layer. This lets extensions to mostly compose nicely.
But I'd say the more important feature is that nothing is sandboxed. That means extensions can detect and work around potential conflicts with other extensions, up to the point of extending or replacing any function such conflicting extension uses (though with proper extension design - which is by this point a part of Emacs culture - this is rarely needed). It's easy for any extension to expose an API layer for interop, and Emacs itself provides enough of an API surface that usually you don't even need to do that explicitly.
More importantly, I myself can trivially extend or fix extensions as well. Something conflicts and errors out? Flip a debugger trap, wait for it to error again, poke around the source, find the culprit, patch it in your config. Granted, you need a passing familiarity with Emacs Lisp for that (though IMO, one should consider getting comfortable with Emacs Lisp a part of becoming a power user of Emacs). But you can do that, quite easily, and the entire environment supports you in doing this.
The main reason is that it's backed by Microsoft, both because of the investment that provides and the visibility it provides.
JavaScript over Lisp probably helps, but if VSCode had Visual Basic as it's extension language it would still be doing strong, and not because VB is a good or popular language independently.
Commentary on our industry seems bent on the idea that things succeed in inherent quality. Reality seems to be full of contrary examples.
In what sense is there a "war"? That's a serious question. Emacs, VS Code, and quite a few of the other popular editors are open source. You can download them and use them. I have both Emacs and VS Code on my machine, and I use both of them, but for different purposes.
Now, if you wanted to talk about a war between open source and traditional closed-up-tight, walled-garden commercial software, I could get on board. It's really hard for me to understand your framing when you have freely available products that are not in any way exclusive.
On your other point, if I were to speculate, I'd say VS Code's main advantage is that it doesn't have a 1970's graphical interface. Port GNU Emacs to Monaco, give it some good default settings, and see what happens to adoption.
If it were a war, they'd just DDoS gnu.org or something, not make Emacs better.
The war is in usage % among users. VSCode is the most widely used editor by far now, reaching over 51%. [1] Usage converts into further growth, having more and better support from extension developers.
[1] https://blog.robenkleene.com/2020/09/21/the-era-of-visual-st...
However, I do agree with you that Emacs onboarding process can be difficult if you don't know lisp, in that you have to now learn a new language and the API for interacting with the editor. That is why some friends and I recently decided to embed JavaScript/TypeScript into Emacs as a means of controlling the editor [1]. We will see if we can prove you right.
Emacs is actually an appliction framework (and a Lisp machine) with a unified interface where one application can share data with other applications via "buffers" very easily because the basic data is text (no proprietary or fancy datastructures that can get outdated at some time). With this underlying structure (plus with the integrated programming language Lisp) you can connect, combine, configure (to your liking) every application within Emacs easily. In non-Emacs world, using isolated apps (islands), I'd "beg" the dev teams to add this or that feature to make it more productive [3]. Not so in Emacs-land, where I can change every aspect of an app within minutes.
I have legacy tools / apps that were discontinued, and my data is stuck in those formats [2], and I don't have the time to migrate those documents.
Emacs is here to stay. And offers many apps (packages) for many use-cases: org-mode for project management, task-management, taking notes, writing complex documents, creating technical documentation with inline images, ascii tables, with embedded code (that can get run via org-babel); lsp-mode which transforms Emacs into a decent IDE; calc for doing basic to complex calculations within Emacs (documents); org-babel for doing literate programming; eshell for using your shell within emacs; mu4e which is a very good email client (says someone who used to use MailMate and was thrilled I could use keyboard shortcuts to control lots of aspects of my email client), and many more.
Emacs is the tool that will grow on you, and it will get better the more you learn about how to configure it.
---
[1]: "a great operating system, lacking only a decent editor"
[2]: EccoPro PIM from the 90s, AskSam (full text database) from the 90s, NoteMap (outliner), MS Access databases (from the 90s/2000s) with old format, and many many more.
[3]: Whenever I liked an app, I'd quickly start writing with dev teams back and forth in forums or via email. Bear.app, Ulysses.app, iA Writer, DevonThink, etc. Constantly writing to the dev teams, asking to include this or that feature.