> It also shines in areas where Emacs doesn’t: if you’re a programmer working on typical contemporary projects, mostly just wanting to get stuff done, things usually… just work. You install VSCode, open a source code file, get asked to install the extension for that particular language, and that’s it. You get smart completion, static analysis, linting, advanced debugging, refactoring tools, deep integration with git, and on top of that, great performance and a cohesive user experience.
These days I mostly use VSCode due to great language server integration (Pylance, gopls, rust-analyzer, etc.), but I still rely on Emacs with Magit for almost all my git interactions. This is not helped by VSCode's shitty commit message box, which after five years is still this ~250x20px by default input field with some after-the-fact validation tossed in. The great thing about Emacs is that everything is a buffer, you get the full editing power afforded by a buffer, not some second-class input field, especially for something as important as commit messages.
On the discussion of values, I'd also like to submit "(expected) longevity" for consideration, which I think is distinct from "stability".
I made the switch from Vim to Neovim as soon as I felt confident that (1) the project was going to be around for a while, and (2) it was on track to "overtake" Vim (you may choose to disagree with me on this, I found built-in LSP to be a compelling selling point, but the specifics aren't really related to the point I'm trying to make). That it was almost completely a drop-in replacement, down to the init file, certainly didn't hurt.
Under the author's framework, Neovim apparently prefers "progressiveness" while Vim prefers "stability", and those two sound dimetrically at odds based on their descriptions; but both have large, active communities that aren't going anywhere. I'm not sure I can say the same about Kakoune, for example, which is a certainly a promising project but hasn't yet convinced me to jump the fence.
[edit for Emacs thoughts]: Now that I think about it, "text centrism" in my mind is also closely related to longevity. I don't care as much about the properties of plain text as I do about the fact that I'll be able to open/view/edit them _even if the application ecosystem dies_. I find Emacs attractive here with org-mode and, to a lesser extent, org-roam (the comparison here would be between e.g. SaaS productivity offerings like Notion).
This is really well written and researched but confuses me. Do most people not do this - make choices based on values (and constantly re-evaluate those choices in the face of new information)?
When I decide to use software, move to a new location, purchase cereal at the grocery store, buy music, and a variety of other daily activities, these are choices I make based on my values. Many times I end up picking something that I find slightly less convenient or usable because it aligns with my values better, and I'm unwilling to compromise my ethical stance for a little bit of convenience.
It seems unrealistic to me that people would choose otherwise, given enough information.
"Maintainability - The degree to which it can be modified without introducing faults"
I can see why VS Code might get the Maintainability checkmark in the sense that it's hard to break from a user POV, but I wouldn't consider it "maintainable" in certain aspects as long as it isn't FOSS. Your IDE/editor is subject to the whims of Microsoft's release engineering team. If you do want to build from the open-source version and have the same experience, then you're going to have a bad time: https://www.reddit.com/r/linux/comments/k0s8qw/vs_code_devel...
I'm curious if the userbase of these have tried a Jetbrains IDE (PyCharm, CLion, IntelliJ etc). I've found the Jetbrains IDEs understand the language more thoroughly - this means better code navigation, error-catching, and refactoring. I've also found the implicit project-first focus (as opposed to file-first) to be more practical for most things I work on.
VSCode has great and convenient language support, but the trade-off is reduced text editing efficiency, slower speed and more bloat. It is a worthy trade-off in many situations, I use it often when working on projects that are written in languages I am not too familiar with.
I would like to emphasize how big of a game changer the next release of Neovim 0.5.0 will be. With builtin LSP support it will get code navigation, auto-completion and refactoring support on the level of VSCode out of the box, while being way more efficient and faster. I will likely still keep VSCode installed just in case, but only expect it to use it in rare occasions in the future.
Emacs is really powerful, but its age is showing and there are some serious technical deficiencies under the hood. I would challenge the idea from the post that the need for "Neoemacs" is not that great. From the history it appears to me more like that many people tried, but due to complexity of Emacs nobody has been able to successfully pull it off yet.
I don’t find VS Code to be a good text editor in the sense of a tool to wrangle text: the keyboard shortcuts are rather arbitrary and don’t seem to be logically organised, and it seems not to have learnt much from eg modern text editors like Sublime Text (even Sublime compatibility isn’t as good as the real thing).
That said, for writing code, it’s fine because most of the time I’m thinking and typing in short runs of text.
I’d love for it to receive a bit of love so it’s a better at wrangling text out-of-the-box, however.
I've tried all of them, and still prefer vim because it's the least hassle to install/configure anywhere - my dotfile setup installs my plugins automatically, and I'm set.
However, I do use VSCode extensively as well, largely because of the language servers. But sometimes it takes so long to start up (and nags me to do so many updates to itself and extensions) that I just toss the window aside and use a native Mac editor (like Textastic) to work while it finishes.
Sometimes I don't go back -- it's all a matter of taste, really.
This was really well-written.
One thing I'd recommend is to think more about "principles" than "values". The difference, in my mind, is that values are sort of ingrained into us as humans, and we can't change them. They include good beliefs but also a lot of personal baggage.
Principles, on the other hand, are things we _choose_ to act on. Ideally they are the same as our values, but when building/designing something, it's best to choose principles.
Are powerful editors really that much of a force multiplier? My career path has pulled me from a CS degree into loosely related fields so I mostly only code as a hobby. I end up using basic editors (e.g., gedit) and reaching for grep/sed/etc when I need something fancy. Is having that power in the editor versus the command line that much of an advantage?
On vim vs neovim: My deep vim usage hasn't really changed much since it stopped being my primary editor usage 5 years ago, so this isn't the world's most informed opinion, but I've not noticed a drastic difference between vim and neovim. The one difference I've noticed and literally the only reason I've moved to neovim is that it uses XDG dirs by default and thereby clutters my home directory less. Otherwise, the two seemed pretty interchangable.
For some reason the real-estate on vscode like file browser etc is really small compared to any other tool, on vs code I always have to move scrolls to see anything, I think this is the main thing why I don't use it while I really want to.
I use Emacs, but I like the polish of VSCode too.
Emacs is a portable programming platform and once you learn it, it's so easy to program that it's trivial to create mini applications with a text/keyboard interface to get things done or quickly automate recurring tasks. (Those who can create VScode plugins and don't know emacs, have no idea how convoluted creating a vscode plugin is, and how trivial it is in emacs).
Even if I happen to do something via VSCode, I still use Emacs for Org, Magit, etc. and also as the above mentioned programming platform, because I found these mini apps with key/text interface help a lot with everyday tasks.
I run neovim within vscode with neovim plugin. Relatively easy and fast to get started, takes time to reconfigure lsp and clean up shortcuts conflicts, but that is about it
I don’t see why everyone needs to have the same opinion and editor, I’m fine with everyone using the editor they like best. It’s a tiresome endless debate
My daily driver is VSCode with Vim editing and Emacs Spacemacs keybindings. I use a VSCode port of Emacs' Magit client for version control.
I'm genuinely curious, from other folks perspectives, what I'm missing with this setup. I've tried standalone Vim, I've tried standalone Emacs (Spaceamacs), and this is by far the best developer experience I've had. I don't know why I would ever switch to another tool, this feels to me like the best of all worlds.
VSCode Spacemacs: https://github.com/VSpaceCode/VSpaceCode
VSCode Magit: https://marketplace.visualstudio.com/items?itemName=kahole.m...
After 10+ years with Vim, and 5 on emacs before that I switched to vscode this year and have been pleasantly surprised.
I tried vscode in 2018 and it wasn’t there yet.
What I like better than vim:
Better integration with python.
Per-workspace interpreter and linter path settings.
Outline view.
Integrated terminal.
direnv and venv both work well.
JSON Schema integration. This is actually what sold it for me.
Edit: format
For me, the value of emacs lies in the fact that it works from the cli ie. Ssh, and that I can use it productively from termux on my phone- with a Bluetooth keyboard I can do split-screen working with ease. Vscode would be considerably harder to setup.
I'm more excited about Onivim [1] than I am about Neovim making Lua a first-class language for writing plugins.
[1]: Onivim is a VSCode/Vim hybrid in the works (https://onivim.io/)
VSCode is Slow to me. Emacs is great for lisp programming and I like the TODO feature of org mode, there’s a lot of useful features, however it’s a bit too different from modern UI so I get a bit jarred using it from time to time —> my job is using many programs, of which an editor is one, so I can’t happily stay in emacs 90% of the time.
I really like Sublime - fast and clean. Currently I use both sublime and emacs depending on what I’m doing.
I wish I discovered emacs 20 years ago! How many years I wasted without it :(
A thoughtful essay. I find myself frustrated with Sublime Text these days, and as a former (novice) vim user, I’ve been debating if I should go for VSCode like all the young guns these days or commit to Doom Emacs to leverage a solid initial setup and my vim memory and fully embrace libre route, which are a little more aligned with my values (although not to the degree of RMS). I remain oddly indecisive.
How was "Editing efficiency" measured. I use emacs and seem to be able to make changes in fewer keystrokes and time than any other editor.
I read this "definition" of philosophy elsewhere: we all share the exact same set of moral values, but their relative order is different. It's the order of the moral values that determines a philosophical stance.
The article starts by recalling this, but then it describes each project by the principles that it holds, but not by their order. This is a bit strange.
Performance should be listed on there too. Without it, none of the other features matter to me. If I type a character I would like, ideally, 0 ms lag. That has to be a starting point. THEN, you can add the additional layers of niceness (while keeping the performance, of course). VSCode certainly does not achieve this (gorilla is being polite).
Nothing to add - just a great article that provides an objective and humanistic review of the field which is extremely refreshing to me.
It invites the reader to consider their values and its mapping to the tooling we use (instead of working backward by having a gut feel of what they like and trying to justify why a specific feature is The Best)
They have wrote such a list of values down but seemingly forgot such values as aesthetics (e.g. Sublime and VSCode look great, at least after you install a theme which suits your taste) and smart context-aware code completion and refactoring facilities (e.g. try IntelliJ once and you are hardly ever going back).
VSCode sends your private data to Microsoft servers. Emacs and Vim don't.
Wasn't emacs forked several times in the past? Would be curious to see an exploration of the difference and why they converged back to mainly one offering. (Or are there others still thriving?)
Noob question: Is Sublime text still a good text-editor in 2021? Did it just loose momentum or not being open-source is insurmountable? I still think its speed and usability are not easy to match.
Perhaps this might be interesting to anyone which wants to give Emacs a try: https://emacs.zeef.com
Maybe I'm lazy but I prefer to buy an intellij product.
Until an editor comes along that is as extensible and keyboard efficient as emacs with lsp integration, or I get one of those combination mouse/ergonomic keyboard contraptions, I'll stay there.
Every other IDE requires mouse usage to accomplish even the most basic commands. With helm in emacs, my hands never have to leave the keyboard. Vocoder comes really close, but still requires you to build a plug in rather than exposing a quick api to do project specific one off tasks with eval or macro recording and repetitive application without using the mouse for anything.
Emacs is a typewriter that comes with a one thousand-page user manual and can also serve as a piano and a chainsaw.
i just wanna know how anyone still uses emacs insanely bad movement bindings
https://github.com/caseykneale/how-to-exit-vim
krrkrkrkKRKRkRKRkrkr.
tldr Neovim is a more actively developed vim. Vscode is a more than good enough editor for all seasons. Emacs is both stymied and celebrated for its adherence to "software freedom."
Editorial: No one cares about "software freedom." If it takes [more than 2000 words](https://www.gnu.org/philosophy/free-sw.en.html) to describe what "free" means (another bad case of tldr), then forget it.
Emacs "doesn't, however, affect progressiveness as much as freedom. Because of freedom, when faced with a question of using technology that is 1. Non-free, but objectively better, 2. Free, but objectively worse, the latter will always be picked. Given that most technological progress happens through the mechanisms of capitalism, "free" alternatives commonly lag behind to a large degree."
Emacs has a degree of integration and customization ability that VSCode just can't touch, so all this talk about VSCode being "objectively better" is pretty myopically focused on just a handful of things geared towards ordinary developers "who mostly just want to get stuff done".
Those aren't the only people in existence, and if Emacs doesn't cater to those it's not because of its philosophy of Freedom, but because it doesn't have enough developers who care to steer it in that direction.
Emacs is an editor-creation toolkit which is about customization, flexibility, and power. Making it easy to use for people who don't want to invest much time crafting their own editor with this toolkit is just not a big priority.
That said, there are some packages like Prelude, which aim at giving Emacs sane defaults and making it easier to use for beginners (though I've never used any of them, so can't vouch for how well they achieve this aim, and I doubt that any of them would give you a full VSCode-like experience out of the box).
To me the biggest weakness of Emacs, but also a strength, is that like a typical large open source meta-project (like Linux, the OS including all the software developed for it, not just the kernel) it's a multi-directional effort of hundreds of volunteer developers each running in their own direction.
There are no orders from the top steering in one direction, no army of paid developers to make thorny, decades-old bugs finally disappear. Volunteers will get to those if they're interested, and go the way their own interests take them.
It just so happens that the stars aligned so that we have the Emacs of today, given the volunteers of yesterday. If they were different volunteers with different priorities, Emacs would be different, and different volunteers tomorrow may steer Emacs in yet another direction. There is no plan. It's an anthill without a queen, with each ant building what it personally wants.
This is why, like mature languages with large ecosystems, like Python, like other flexible editors (ie. vim, with its many plugins), and like Firefox (with all of its extensions) you have packages that "interfere with one another, depend on functionality from other packages that get deprecated, changed in incompatible ways, or removed."
You really can't have a large package ecosystem developed primarily by volunteers and not have this problem. People work on what they want to work on, and if they don't want to spend the time maintaining their package or making sure it's compatible with whatever package combination any particular user happens to be using, then there are going to be incompatibilities.
But I'll take that incompatibility in a heartbeat for the enormous flexibility and power it offers, especially if the alternative is a meager, inflexible package ecosystem where how I edit is dictated from on high by people who cater to the average developer who "just wants to get things done".
If you want Emacs to be something else you either have to be really good at herding cats, do it yourself, or pay someone to do it for you. Even then, you'll have to somehow convince all of its users to switch to your "improved" version. Good luck.
I don't like any of the three. I like Xcode, even better now that interface builder is destined for the garbage heap.
I use vim frequently. But I think that people should realize and be able to admit that vim and emacs are outdated. They can still be useful especially for people like me who have a sunk cost in learning them. But the honest evaluation is outdated. For example, the core modal interface of vim is related to historical limitations at the time it was created.
http://xahlee.info/kbd/keyboard_hardware_and_key_choices.htm... Basically historical happenstance has become part of multiple religions defending dated programs.
My current favorites are Jupyter Notebooks and the combination of gedit with fish shell.
VSCode is great but a lot of times feels like overkill and a little bloated.
Our text editor is a tool, there’s no fundamental value in a tool vs the other, they do not possess life. They’re tools like a fork is a tool.
I wonder what of the things you use in the day to day you analyze so deeply, your microwave ? The forks you buy?
Might be an interesting exercise of thought but for something that I use to make money, I will use the best tool available for the job, thank you very much.
The Neovim section participates in the popular sports of ganging up on top developers who have spent decades of their life in the public interest, for free.
The Neovim developer is called its "author", which is poor form and probably a copyright violation. Go and write your own editor from scratch.
When you finally learn to master and config Emacs, you run circles around all other editors. Emacs is so much more than just an editor. But even if you only use it for coding: Magit is the best git client I have used in years (coming from PyCharm + Git Tower App, which is nice), then there‘s Ztree-Diff (excellent folder diff tool; previously using Kaleidoscope app), then Eshell for interacting with the server from within Emacs (programmatically if you like), Tramp for remote editing, excellent integration of ripgrep and silversearcher (ag) into Emacs for code navigation, yasnippet as an excellent templates/snippet manager, and many more packages.
What makes Emacs exceptional is you can link all these packages together, create your own workflows by scripting Emacs in Lisp. And I write the docu in Emacs in org-mode, with org-babel I can run shell-scripts / python-scripts and other code in my org-file and see the output underneath it (like Jupyter notebooks), link to code fragments in my org files etc
I manage several projects with it and switch contexts with one key-combination: Vagrant box is started, project folder is changed, necessary files opened, ready to hack, build, deploy, do server restarts with a single key stroke.
I think VS Code is a nice coding environment with good defaults and many things done right (compare installing packages in VS Code to Sublime! What an improvement) but nowhere near the capabilities and the productivity of Emacs.