Modern IDEs are magic. Why are so many coders still using Vim and Emacs?
Developers are a finicky bunch. Like a dog refusing to walk on wet grass, there always seemed to be a bit of resistance to changing up a routine. We love what we grew up with, be it Star Trek jokes, Vim, or Emacs.
The origins of this war harken back to Usenet groups in the 1980s, a time when Vi and Emacs were the primary tools used for coding. Emacs, as we well know, is a “maze of twisty little passages, all different,” (an old programmer’s joke that came from the game Colossal Cave Adventure) while Vim (and Vi before it) offers an arrow-controlled universe of keyboard shortcuts. Both are used in coding, editing, and administering systems. And, though we hate to say it, both have reached a point where neither seems to really want to fade off into the sunset.
The endless war between Vim and Emacs users has continued ad nauseam over the years. It’s less a war at this point than a grumbling shuffle of ingrained habit and stubborn resistance to change. Vim and Emacs users, once at each other’s throats, seem to have implemented each other’s keybindings (a thing they actually do) to take on a common enemy — any modern IDE.
Vim: The high availability IDE
The consensus among many Vim/Emacs users creates a picture many tech users from a certain generation would be familiar with. As my father would attest, using his Microsoft Zune long after its support ran out, if it ain’t broke… While there are many IDEs on the market, there’s no reason to use one if you don’t have to use one. It’s the same reason I am still using Notepad to compose and not some fancy text editor or CMS tool. It just works.
“The reason I avoided IDEs to begin with was that back when I was getting into Vim, like a decade ago, it was an extra license to look into,” says Vim user John Carter (not of Mars). “Since then it’s become a question of ‘code speed.’ If I start with a new IDE or even switch to something like Emacs, I’ll slow down. On an emotional and professional level, I can’t really afford that. It takes energy to pivot to a new editor. I don’t have that energy. I got the job, a family, and side projects. It seems silly but that kind of pivot takes energy.”
Vim is always available. Any Linux machine has it. Vim has a small footprint, low latency, fast startup, allows for more screen space, customizable and most importantly, once the muscle-memory has been ingrained, it’s nearly impossible to switch to something else.
Continues Carter: “Our fingers are often the bottleneck between thinking up code and getting it in the app, so that’s where folks look to optimize shortcuts.”
Take Atom, one of the more popular IDEs/editors. Atom is a free, open-source text editor that bills itself as being “hackable to the core,” allowing for multiple customizations. It has cross-platform editing, four UIs, eight syntax themes and integrates with HTML, JavaScript, CSS, and Node.js. Most importantly for users who didn’t start coding in the last five years, there is a Vim Mode package. This has led users to literally turn Atom into Vim, unable to let go of the past, unwilling to fully embrace the future of code editing.
Most IDEs create entire worlds where developers can create, but creating requires configuration. It takes time to adjust that world, to play god, to create shortcuts and hotkeys, to get used to different command structures and UI. While a coder could sit down at any terminal and begin working in Vim, that isn’t true for any IDE. Further, IDEs are often too much tool for the job. Beginning programmers are much better served by simple text editors vs. massive programming behemoths.
As coders’ careers evolve less through their expertise than who is signing their paychecks, there is always a constant code editor available to them regardless of which IDE the company prefers. It could be seen as an act of willful defiance or just personal preference, but text editors are always there.
“Primarily it’s about ubiquity,” says BSD runner Tim Chase. “I can sit at any Unix-like terminal (Linux, BSD, Solaris, whatever), type ‘vi’ (or ‘ed’) and have a powerful editor that works even if my terminal isn’t configured quite right (e.g. sending certain keys or key combos) and without needing to install anything.”
Familiar and comfortable
It’s this type of comfort that has kept whatever perceived war between those still using Vim or Emacs and the prospect of using IDEs going for as long as it has. It’s mental mom’s spaghetti (or insert your comfort food here). Vim and Emacs are always there for you, cozy, calm and willing. While an IDE is some weird new food with all kinds of exotic ingredients that requires tenacious and irrational picking with the fork to get it just the way you want it. The disconnect is apparent and, at this point, understandable.
There is some shiver of recognition among developers though that perhaps switching to a full IDE is not as unbearable as it sounds. There is a resignation in finally realizing that in order to do the job, you use the tools available to do the job, no matter what those tools may be.
“I say, whatever helps you get your job done, use that,” says not that Tom Hanks. “Sometimes the more modern IDEs can get in the way, other times they are indispensable. Visual Studio, for example, has massive performance issues when there are too many files associated with a project file. The entire application becomes very sluggish. A few years ago when I used PyCharm for Python development, it would sometimes become ‘confused’ and give bad feedback on its syntax analysis. Basically, it was making you think you had made a mistake when in fact everything was ‘fine.’”
That said, if you’re new to programming, a modern IDE could be helpful. With code completion, Git control, and even automatic deployment systems, modern IDEs are a Swiss Army Knife of features. And, like most Swiss Army Knives, you don’t have to use all the features to find them useful, especially if you’re just starting out. Many of us won’t use, say, the hole punch or the toothpick, but it’s nice to know it’s there.
Whatever war might be raging behind the screens of coders between Vim, Emacs, and IDEs really doesn’t matter. Vim and Emacs aren’t going anywhere anytime soon, no matter their antiquated status in modern development environments. IDEs will keep improving, keep launching, and serve an ever-growing segment of young developers who were never forced to thrive in Vim or Emacs environments. The best advice to anyone struggling with choosing a preferred program is to just use the tools available to get the job done. Or, as the popular 20th century poets TLC so deftly declared, “Don’t go chasing waterfalls, please stick to the Vims and Emacs that you’re used to.”
Tags: emacs, ide, vim
210 Comments
There’s not really a war with Emacs / Vim anymore because they both offer the same advantages over modern more mouse driven IDEs. I think the core reason people don’t abandon Emacs or Vim is that today with plugins they can do 90% of what a modern IDE like intellij / VS Code can do but without having to have one hand off your keyboard and lose typing efficiency. I concede that the systems are outdated and less efficient by far to setup and somewhat conveluted to use in cases, but if the hours are put in up front they can level out. I use intellij, VS Code, Emacs, occasionally Vim, and a few others from time to time. Emacs is still the most efficient for me because of my own customizations and the lack of reliance on a mouse. I wish intellij had better thought out text navigation and wrangling (yes I know about Vim/Emacs plugins, but they aren’t complete and only offer the basic navigation).
I’m sorry to say that but that was a very uninteresting and badly informed article to read. I’m OK with people saying I use old and has-been tools, but then I expect solid and interesting arguments.
First, claiming that vim and Emacs are now united against “modern” editors, because they implemented each other’s keybindings is ridiculous. Yes you can now even run vim in Emacs and have the best of both worlds for example, but that has nothing to do with the availability of more recent editors.
I don’t know about Vim, but the reason Emacs is not “fading away in the sunset” is not because it is available and running everywhere (it is) and some old nerds are used to it (they are). It’s, I think, because Emacs is a mature, proven, stable, and powerful self-documented, fully programmable lisp machine, with hundreds of high quality plugins, and a vibrant community, still actively maintaining and evolving it.
I complete agree: a very uninteresting, badly informed, extremely biased, picking-a-fight kind of article.
For those readers who want something better, consider this.
I have used many of IDEs over my forty-year (so far) career. I prefer (Neo)Vim. The author seems completely oblivious to the fact that most of us pick text-based editors over IDEs with very specific and conscious INTENT. We are making an architectural design decision, a cost/benefit judgment, a technical evaluation and selection.
IDEs have a LOT of downsides.
For example, Visual Studio was infamous for crashing due to memory leaks and performance problems. It is quite difficult to get some code written when your IDE crashes a lot. Many modern IDEs are immensely complex, and overwhelmingly BUSY, and SLOW.
Perhaps the simplest and truest explanation for avoiding the use of IDEs is that they are GUI (gooey, as in sticky and yucky). 🙂 Using a GUI is slower. Using a mouse is slower. Both are error-prone. So advanced users tend to not use GUIs. They likewise tend to prefer *nix over Windows, and they tend to prefer a shell over endless clicking to configure their machine. They want to focus on function over form, substance over superficial appearance.
It seems that the author has no idea that every good IDE feature is available for nearly every text-based editor (particular Vim and Emacs). Auto-completion is available, works better, is easier to configure, and performs better–in a text-based editor (IMHO).
I read between the lines that the article’s author is NOT an advanced user, and so they have NO idea what true productivity is available when using powerful tools like Vim or Emacs (or the shell).
An IDE tends to lead to laziness, or perhaps it is a sign of pre-existing laziness. Do you know what the IDE is doing behind the scenes when you click that button or select that menu item? A good technician should know their tools, and should communicate them to other team members and to those who will follow. An IDE leaves little trace of how you built your code, how you packaged it, or how you deployed it. An IDE cannot be incorporated into a Continuous Delivery pipeline.
An IDE is almost impossible to configure consistently across all the members of a team sharing a code base, and it SHOULD NOT HAVE TO BE. Each person should be free to use whatever editing tools they wish, as long as an acceptable result gets committed to the source code repository.
This article reads like it was written by a petulant child. Go do your homework, little boys. Leave the real work to us adults, please.
I’ll give you my reason: It fits into the unix toolchain. I live on the command line and the fluidity of using vim there is unparalleled. And full disclosure I recently “switched” to nvim, so you’re totally wrong that I am adverse to change :P. IDEs are generally “top-down” apps that are essentially an entire environment unto themselves. Vim can be that too, but I find it better to work the other way. To start with the command line as the environment and use vim as one of the tools therein.
I grew up on old-school Macs with BBEdit and other non-modal editors. On Unices I used nedit for years, which is pretty much the equivalent, but via osmosis I slowly learned vim. Eventually I just decided to really learn it and bend it to my will, and I’ve never looked back. I find vim to be much like playing a musical instrument, you develop the chops with lots of practice, and you can always learn new techniques even after many years. Still I clumsily “miss notes” occasionally and wind up off in the weeds accidentally. Regardless I find it more fun and enjoyable to use since it is mine.
Modern IDE’s by default present numerous visual distractions, and try to improve your productivity by guessing what you’re about to do next. I’ve been coding for a long time, and I find these suggestions annoying since well written code doesn’t have a lot of predictable boilerplate content anyway.
This is like old, grumbly climbers arguing as to why they’re ATCs are “good enough” in the face of safer, modern devices like the Grigri.
Us young whipper snappers just don’t understand/respect our cultural roots…
That’s great, i use many IDEs at any given day when i want to compile code, but i still need to use vim or emac or nano when i am on the shell, say ssh into a server or docker instance and want to write some scripts or change configs etc.
Um, what about “runs in terminal mode locally and over SSH”?
I love vscode and jetbrains but they don’t do that. And emacs is an IDE.
B
Incredibly, I miss Windows EDIT very much.
Thanks for the fun article. I’m glad you didn’t take sides 🙂
For those who are thinking “maybe it’s time to learn an IDE”, I’ve found that the best time is while also learning a new (and preferably modern) language. Especially in cases where the editor and the language are close friends (e.g., VSCode and TypeScript), learning the two together is a good way to trick yourself into being willing to ignore all the muscle memory your fingers have, and into being open to learning the tricks that the new IDE offers.
there’s no benefit at all in “learning a new IDE”. vim (and emacs) is here to stay, it has proven to survive many versions of many IDEs, who uses Borland, CodeWarrior today? they were “modern IDEs” back in the day.
vscode is nice, but it’s not “more modern” and it will never ever succeed vim. it’s also not trying to. the whole article makes wrong assumptions. bunch of noob coders i guess…
This is a profoundly clueless article. Many, if not most, Vim users *also use IDEs*. I spend virtually all my time in an IDE, and Vim is a crucial part of that.
First, Vim is more than just an editor, it is an *editing model*, and superior one. It’s a combination of several things:
1. Modal editing, where commands are issued using *non-chorded* keystrokes, which allows editing at the speed of regular typing (i.e. fast as hell).
2. A grammatical command language, where sophisticated instructions can be composed from verbs and nouns, then qualified with counts or repeated with a single keystroke. Because Vim is modal, these commands are plain text, human-readable and editable.
3. Every key on the keyboard is a register, which can store sequences of these text commands, which can then be played back or even composed into more complicated actions.
4. Commands, sequences of commands, or sequences of sequences (macros composed of other macros) can be bound to keys on the fly, again by *typing* plain text (which means you can even bind a command that binds a command).
Vim is much deeper than that, but these factors alone makes it absurdly powerful in the hands of an expert. It’s like a text manipulation *engine*, where you build up text transformation tools on the fly, quickly, intuitively, that you’d otherwise have to write custom code to do.
Second, crucially, Vim’s editing model is *portable*. Because it’s so ubiquitous, this editing model is supported by almost every major editor and IDE. If you have 10 different tools, you have ten different keystrokes for “copy line”, “copy to end of line”, “copy word under cursor”, etc. assuming the tool you’re even *has* keystrokes for those things (a lot of tools have poor/anemic editing models). This an exponential explosion of keystrokes you have to learn if you want to be maximally efficient in every tool you use, so most people don’t even bother investing in deep mastery of all their tools.
Or you can learn one Vim’s model once and use it everywhere. My current job requires both Windows and Linux. I use Visual Studio, IntelliJ, Visual Studio Code, and SQL Server Management Studio half the day, and the rest I’m working through a terminal. I use Vim, everywhere, all the time.
Vim is not some tool used by old dinosaurs clinging to the past. There’s a constant influx of new users, who often become converts once they reach a level of mastery that they grok the advantages of the model. If you’ve learned just enough to exit Vim, you’re arguing from a position of ignorance, which is obvious given the article.
tl;dr: Vim is a superior and portable editing model available in a huge number modern tools.
Spacemacs, the best of both worlds.
Vim and emacs are equally obtuse, but emacs is a full blown lisp machine. It will do absolutely anything you want to unreasonable levels. People learn vim because its always there. People move to other editors because vim isnt easily extensible. But they already learned modal vim so they make the new editor like the old.
Emacs is timeless. No replacement necessary.
Vim is indeed very extensible. Apparently another uninformed opinion. But otherwise agree.
As a 6-7 years Emacs user, I have to say I do not recognize myself in your article. I started working as a developer using eclipse and other IDEs , and felt I was spending too much time switching between my keyboard and my mouse.
This incited me to try Emacs, which is mostly (but not only) keyboard-driven. I discovered a fantastic piece of software, extremely extensible and carried by a community who creates excellent packages.
From time to time I try newer IDEs to see if I can find something even better because yes, I realize the time I spend to fine-tune Emacs to get IDE-like features is a bit of a shame when newer editors have it out of the box.
But I eventually come back to Emacs. Org mode is so useful it became a major part of my work flow. Magit is so powerful I never get the issues my coworkers have with git. Emacs ‘ consistent textual interface spoiled me so much for years that seeing all these panels in modern editors that each have their own rules disappoints me.
So in the, I wouldn’t say I’m using Emacs because I don’t want change. I use it because I wanted change and I got “rewarded” for it.
My experience reading discussions in the Emacs community is that I’m not an exception. A lot of people actually use Emacs because common editors doesn’t quite suit them and they want to try something different.
In the end it’s all about people and their workflow, I think, Emacs and vim have a big learning curve but they worth it if you have the compatible mindset.
Now, I was a bit puzzled when I was reading your article. Emacs vs vim vs modern IDE war? The Emacs – vim war is, afaik, nothing more than a joke today. Each community benefits from each other. Regarding modern IDEs, at least in the Emacs community I don’t see any hostility toward them, they even collaborate on subjects like LSP which would have never existed without VSCode. I would like to know what gave you the feeling there was some hostility here, maybe I missed something.
I hesitated to write this comment to be honest… Everything that’s said in your article is very far away from my experience with Emacs and the Emacs community. I am not a native English speaker, so I thought I may not have seen some irony / sarcasm in what you wrote… Please tell me you are serious and I am not embarrassing myself by answering while having missed the point totally 😀
Just a note, you can have your cake and eat it too. I use Vim inside Visual Studio. 😉
> That said, if you’re new to programming, a modern IDE could be helpful. With code completion, Git control, and even automatic deployment systems, modern IDEs are a Swiss Army Knife of features.
Quite literally every single one of those features has found it’s way into Vim and Emacs. With just a couple lines of elisp of vimscript you get access to LSP-powered autocompletion, formatting, refactoring and linting. A couple lines more and you get Git control as well. And then you can take all that and just use the same editor with any number of different languages.
The author has never taken a deep dive into VIM or EMACS. Both have all of the features of a so-called “Modern IDE”. It just take a little configuring.
Huh? Emacs also has “code completion, Git control, and and even automatic deployment systems”.
“With code completion, Git control, and even automatic deployment systems”
I…have all of that in Emacs? I write Java, for a living, and use code completion in Emacs every day.
I’d also be shocked to find that Vim doesn’t have Git control.
This post makes it sound like Emacs and Vim are just Notepad with funny bindings. We don’t stick with Emacs because it’s what we’re used to – we stick with it because it’s powerful and, above everything else, flexible/configurable/rewritable through its near entirety.
I find myself incredibly irritated by the attitude of the article, which is that vim/emacs are antiquated tools with no future in modern programming, but that some people can’t get give up on these old-fashioned tools. I admit, I love vi, but I’ve tried various IDEs. Some are OK, some are great. None have anything I need to be more productive. Of course I should give up the productivity I get with vi/gvim because some opinionated person thinks that I am “unable to let go of the past, unwilling to fully embrace the future of code editing.” What hubris.
Vim and emacs are still used not because developers are too stubborn to let go, but because their editing methods are simply more efficient that using mouse for navigating and keyboard for typing. Vim is a modal editor which means you can perform any command directly with the keyboard. no moving the mouse, no switching hands. Also vim and emacs are simple, fast and customizable. most other IDEs are not customizable as much and end up being annoying. Also an IDE is a conplex piece of software, which you really don’t want to deal with when you are coding. Vim just edits files. And if you need anything extra, you install a plugin. That is how a code editor SHOULD be, imo, it is not deprecated and modern IDEs are not doing it better.
I wish there was a modern vim. A minimal text editor with a scripting language and good plugins. but I don’t want to run a fully motorized software development kit just to edit a file or browse my project.
“IDEs will keep improving, keep launching, and serve an ever-growing segment of young developers who were never forced to thrive in Vim or Emacs environments.”
This kind of statement really annoys me. I’m 24, and I have used plenty of IDE’s, but I really prefer emacs for most things. Please don’t paint with such broad strokes. With apologies to the old guard who probably know the correct terminology better than I do, I’ll elaborate.
Sure, I am using cua-mode (which means I don’t have to re-learn the kill/yank stuff), but the fact that I can make emacs work the way I want cannot be understated. It has some great features, like multiple “panels” so I can look at two spots in a file at once, or look at a file and a terminal/python REPL/Lisp REPL at the same time for fast testing. I know more “advanced” IDE’s will do this, too, but while in the 80’s emacs was a butt of jokes for how huge it was it’s not really that big by comparison to something like Netbeans or an Electron-based program, especially if you’re not using a “fully-featured” build. Its startup time is also good, and it can run in a pure text mode, which is handy for SSH sessions where X11 forwarding would bring a huge performance penalty.
Also, emacs still has people writing metamodes and is still evolving today; it’s probably one of the most common places to see Lisp being written today.
I’m not going to say that more “modern” IDE’s aren’t cool or good (I don’t like writing Java without one, for instance), but it’s not always necessary and there’s a definite tradeoff.
This seems like you have never actually used emacs. Add emacs is able to do everything sin can do and is free and open source. After a decade of using vim I switched to CLion and was very happy since it had vi key bindings. Then I changed positions and couldn’t use CLion any more. Then emacs came to the rescue. I have it set up as a full fledged c++ ide with vi key bindings. Everything I could do in CLion or vim is there plus some.
I would suggest checking out spacemacs as an easy starting point.
Ahem, your article is very incorrect.
I’ll start off by mentioning that I use IDEs over Vim or Emacs most of the time. Nevertheless, I do use both these tools (yes, both!) quite a bit, on an everyday basis.
But you, my friends, talk like you’ve never used either tools in your life.
> Vim shortcuts
Anyone who has used Vim would not call them shortcuts…
> Atom has 4 GUIs
???
> With code completion, Git control, and even automatic deployment systems
Both Vim and Emacs have these. What are you talking about?
> Vim is always available. Any Linux machine has it.
NO. As a Linux distro dev, I can guarantee you that every system DOES NOT have Vim. I can’t express the stupidity of this. Most Linux systems have vi, because that is built into many coreutils packages. Vim is COMPLETELY DIFFERENT, only based on Vi originally.
[Editor’s note: I think there’s some valuable discussion in this comment, but I removed a lot of the hostility. We get that you have strong feelings, but keep your discussion civil.]
Apologies once more,
Bobbbay
I love using a good IDE, I use VSCode which is the only worthwhile thing to ever come from Microsoft. However, a few years ago I was with a contracting outfit doing a lot of Linux work. VIM was always there and if you could use it you could program in any Linux shop.
Emacs and VIM are much more than an IDE. I use Emacs to write my website, journal articles, books and manage my projects.
Are the authors being obtuse to raise controversy on purpose, or have they really never themselves used vim and emacs? I switched from vscode to emacs because *emacs* was more feature-complete. Vscode is great but it’s significantly less extensible than emacs by design and when I finally got fed up with the consequences of those limitations and switched to (spac)emacs, I found the latter did everything I liked from the former better.
I would suggest google searches on “vim syntax highlighting” “emacs syntax highlighting” “vim code completion” “emacs code completion” “vim lint” “emacs lint” “vim git integration” “emacs git integration”
So at some companies I’ve worked at, sys admins wouldn’t install emacs on Unix servers (AIX). So it was vi or nothing. So i learned vi. Now i’m ruined. 🙂
You’re fundamentally missing the issue of why vim works rather than a “modern ide”. It’s all about how people program. We spend the vast majority of our time EDITING existing code, rather than creating new code. This is why vim is a text editor, and ides like Atom or VSCode are not. Vim focuses on keymaps, both built-in and user-defined to quickly and without a mouse, jump around, change and manipulate text and code, in a smart way.
The other thing is that vim is just fast. I spent a couple years in VSCode and everything about it felt slow and not well thought out. The git integration is not helpful and the opposite of intuitive, as such it would be better off left out entirely. It’s also using a terrible javascript based environment which is slow, buggy, memory intensive and might well be considered a memory leak by design.
Simply put, it doesn’t matter where I am, I can scp my vimrc over, and get to work without having any sluggishness or inconsistency due to different environments. Additionally, it doesn’t matter if I’ve got 16 cores at 4.7GHz or a single 500mhz arm core, vim performs the same.
Simply put, vim requires retraining to really understand, but it is better for people who care about rsi, people who care about speed and efficiency, and people who simply want a consistent environment across multiple machines.
“Beginning programmers are much better served by simple text editors vs. massive programming behemoths.” – Sure, if the IDE is cumbersome, arcane, or extremely sluggish then that can be a pain point, but a well-designed and reasonably unobtrusive IDE can be an absolute blessing for a beginning programmer. Questions on Stack Overflow from beginners who “want to use just Notepad” to “learn” Java end up in long discussions about classpaths and compiling and whatnot; it’s like having to learn how to build a kitchen before you can start learning how to cook.
Even though Python is much easier for a beginner to grasp environment-wise, a good IDE like PyCharm still offers code completion, integrated debugging, PEP-8 hints, smart refactoring (not just rudimentary find-and-replace), regex testing, and a host of other helpful gadgets. Beginners may not take full advantage of them right away, but (thanks to “tips of the day”) they at least know that they are there.
IMO, recommending that a beginner “learn” by just using Notepad (or Vim, or nano) is most likely doing them a grave disservice.
Aye, these are very good points. I don’t use an IDE these days, but when I started programming (Java, using JBuilder) the IDE provided a nice leg-up. At that stage, the important thing was learning how to write a program. Mucking about with environment settings, makefiles, of task runners distracts from that, and can be learned soon after.
On the other hand, I had learned HTML a few years earlier using… just Notepad.
I do think there’s a role for IDEs aimed at education. A great example would be the Arduino IDE. Setting it up involves picking your board from a menu, and there’s a nice dialog for importing libraries too. The whole compile-and-deploy thing is done with one button. The entire IDE is quite minimalist, and doesn’t come close to the complexity of Vim or NetBeans because it doesn’t need to. The Python and Scratch tools bundled with Raspbian are in this area too; the Python tool include a simulator for the Sense Hat add-on board, so schools don’t even need the actual hardware for every pupil.
I just went looking for a “tip of the day” plugin for Vim, and found at least half a dozen of them 🙂
There’s also the understated issue of making sure the resources you need are not being controlled or paywalled by any future entities.
EMACS and Vi/Vim are forever free (as well as some of the others listed) and there is no chance that somebody Microsoft or Oracle will be able to copyright them..lest some government says it so.
Thusly, the ‘old-school’ users (not always cheapskates) may be able to make their devices work for their own needs..
As one particularly pugnacious plebian said to me:
‘Install Gentoo’
This article is clickbait, ad hominem, and the authors (who do not write programs for a living) are not able to conceive of the possibility that people would understand all of the claimed benefits that “modern IDEs” have to offer, and CHOOSE vim/emacs because it is better.
Framing it as “willful defiance” and “stubborn resistance” betrays the authors’ ignorance. But the ultimate conclusion is still right: it doesn’t matter what people say. Those of us who are willing to learn to use flexible, useful tools will continue to be far more productive than those that resign to be unable to do anything not given to them by their IDE.
Err… Emacs has code completion, git control, and automatic deployment systems.
I restrain myself from criticism based on the evidence that you are not a Vim user and don’t understand the most important points about which your opining.
There was never a war between Vim and Emacs. Emacs is a single mode editor like every other and requires use of chords, chords and more chords. Like one Vim user put it “it’s chords all the way down”.
Vim is a dual mode editor and that feature alone unleashes a storm of fast efficient functionality that can be used from second to second as you type. This effectiveness has never been bettered in any editor since, although it has been emulated many times.
I’ve tried using different IDEs to replace Vim, but it’s too frustrating to go back to the extremely slow and limited management, navigation and basic editing tools, and I don’t see the point. There’s no value proposition available today where that makes sense.
Stubborn and irrational resistance to change? The question I ask is why are so many coders, people that I would expect to be able to tolerate high information loads and deep complexity, why are so many coders resistant to learning the few basic Vim commands that would set them free to greater efficiency and power, not only in a windowed environment, but also when managing headless servers and working remotely?
I am a 24 year old developer. I’ve been working professionally for about 6 months now. I use vim, any IDE is incomplete to me without either vim emulation or an nvim connection. Modern IDES have the main advantage of being mostly ready to go out of the box whereas vim requires a mountain of config to reach a similar level of functionality. However the main advantage of vim is the speedup in thought-to-code translation time. With marcos, registers, and the modal nature of vim you can format, modify, create code significantly faster than if constrained by mouse movements and precise clicks. Once you get used to vim, not using vim feels lackluster and slow. I encourage all young developers to give vim a shot!
> That said, if you’re new to programming, a modern IDE could be helpful. With code completion, Git control, and even automatic deployment systems, modern IDEs are a Swiss Army Knife of features. And, like most Swiss Army Knives, you don’t have to use all the features to find them useful, especially if you’re just starting out. Many of us won’t use, say, the hole punch or the toothpick, but it’s nice to know it’s there.
I mean, those are all available on Vim/Neovim and Emacs. I think you’re vastly underestimating how configurable Neovim/Vim and Emacs are.
I switched from modern IDEs to Vim. Steep learning curve, but so worth it.
referring an IDE rank list of 2017? what day is today?
There are two assertions here that are not accurate.
The first is that editors like vi are not as feature rich as a modern IDE, and it’s that simplicity that attracts developers shy away from the “weird new food” of an IDE. To the contrary, vi+plugins can be just as feature rich as any modern IDE or as feature lean as desired, and what makes it even better, the only thing needed to have a universal experience across all a developer’s terminals is an easily source-controlled set of dot files.
The second incorrect assertion is that vim users will go out of their way to use vi or to find “Vim mode” on modern IDEs because they’re “unable to let go of the past.” There is some resistance to change, but it’s not stubborn or dogmatic in nature. Learning the many keystrokes of vi and emacs takes time and practice, but the end result is a developer that can edit code much faster than a developer using the competitively narrow range of key shortcuts a modern IDE provides (see: efficiency competitions such as vim golf). vi and emacs keystrokes are, by intention, as complete and efficient as possible, and all without needing to switch hand position between keyboard and a mouse. Classic editors, once mastered, have a way of cognitively disappearing from the coder’s awareness, leaving the coder alone with the code and giving them enormous editing speed.
Very interesting. I ditched the IDEs to use Vim and I’ve never been able to look back.
(neo)Vim us amazing and today with the work that the community has done, birthing Coc.nvim, a LSP client for (neo)Vim and the numerous extension, (neo)Vim users have the power of language ItelliSense inside the amazing editor.
The limit is in the skies, but when you put tmux(terminal multiplexer) and fzf(command-line fuzzy finder), the limit is beyond the skies.
It’s been 2years now on (neo)Vim. It’s been splendid.
Modern IDEs are indeed amazing (always have been, really).
If you don’t use Emacs or Vim, and/or you don’t have a historical relationship with them, that is likely the source of your surprise that they’re still heavily used. Emacs is arguably one of the most powerful things ever developed, and I can make it do anything I want by writing Lisp. It’s opensource and it integrates natively with Unix in a way that no modern IDE would even…consider. That’s basically where it evolved. And the Emacs community in general is ridiculously intelligent.
Should someone with less computing experience prefer a pointy/clicky IDE because it’s easier for them to start learning JavaScript, then that is their journey, not mine. The new norm of inexperience with so many new people — who all kind of copy each other’s bad habits — is unfortunate, but it doesn’t mean there won’t always be companies producing really nice graphical IDEs for people to buy. 🙂
There is a disconnect between the knowledge of old Unix wizards and what the newcomers to Tech perceive as valuable. A lot has changed in 30-40 years, but a massive amount of fundamentals are unchanged.
I’m an old unix wizard and now rather out-of-touch with modern unix (aka Linux) – I learned vi long before I used Windows. Yes, I was always frustrated by notepad (and edlin!!) and the fact that no one in the Windows world had even heard of a regular expression. However, it’s really not true now that modern IDEs are ONLY pointy-clicky – they have decent regex support, very good column editing facilities and you can configure them to be basically how you want them to be. I feel no temptation to use vim, but I am much happier using bash now than Windows explorer.
If I were to choose my editor, it would be one compatible with Brief – I have never seen anything better for quickly getting 2,3,4…N separate panes on the same file. The only thing that is currently brief compatible is very expensive.
Oh, please. I was an EMACS wizard in 1989, when that was the only thing available to me. I was the guy who customized EMACS to make programming easy for all my colleagues. I’ve long since dumped it in favour of modern IDEs that _I_ don’t have to customize.
I wish that electronic medical record systems had a vim mode. I tried to get access to the data elements used by Epic and was repeatedly told that was off limits. We have to be button clickers. The frustration (especially when overlaid on sleep deprivation) drives me bonkers. -a physician/scientist also trained in programming, age <40.
OK Boomer! you are being a bit condescending toward the modern IDE’s and today’s developers, you ‘re pontificating from your comfort zone worn out like an old shoe.
Your perspective is outdated: The expectations on today’s devs are met using today’s tools, problems have new solutions therefore new IDE’s, or modern text editors like VSC, or modern frameworks or even languages your dismissiveness of Javascript echoes the trite cliché of old Java programmers “someone with less computing experience prefer a pointy/clicky IDE because it’s easier for them to start learning JavaScript”, talk about sharing each others old habits: if writing Lisp makes you feel so superior to those writing Javascript, realize that ‘lowly’ JS is actively employing thousands of developers and driving a lot of real life paying projects, while Lisp even in AI well not so many, and eventually both will fade like many other like Fortran etc. If U can’t stop the new incoming paradigms you’re left only with bickering.
Doesn’t have time to learn a new editor that could potentially make his life a lot easier. Seems a bit absurd to me. I love Vim, but it doesn’t compare in any real way to full-fledged IDEs.
I have used vi since my university days in the early 90s, I have a nice set of vimrc & extensions all custom configured that i like to use.
I rarely use it any more, though. Vscode is my text editor, my debugger, my file explorer, my terminal emulator, my ssh client, my build system and error parser, my embedded executable uploader, etc…
Just turn vim into an ide. You can have pretty much everything with plugins.
I’ve learned a lot of IDEs over my career so far but vim is so far the most full-fledged. This article makes the mistaken assumption that you wouldn’t have code-completion and static analysis running in the background with vim. It certainly takes time to get these things configured, but not as much as it did ten years ago; with the introduction of package managers, installing ALE and LanguageClient has become a piece of cake. You just have to know that these things exist in Vim, and ignore the many who have a very limited view of what it can do.
100%. You will never get the free pears unless you take time to plant that pear tree… I agree it’s a false economy not to adapt, especially in the tech industry. Do yourself, and your employers a favour, and always make time to modernise…
World renowned programmers like Donald Knuth or Linus Torvalds tend to use Emacs or Vim.
Mid-range programmers sometimes use Emacs/Vim, sometimes IDEs.
Beginners, teenagers learning to code tend to use IDEs.
I use an IDE. Last year, I didn’t know what a pointer was.
So what? Well, maybe there is a reason for this. Other than “those top programmers really should learn how to be as efficient as newbies”.
Don’t believe assumptions made in this post: I use Emacs because it is the *best* tool for the job. I’ve moved from so called “modern IDEs” to Emacs not because “I used to” Emacs *I didn’t know Emacs at the time* but because it did what I needed it to do. So the “you’re used to” point in the post is wrong. The second point about vim vs. emacs war is also presumptuous (is it April’s Fool already?). No need to paint all vim/emacs users with the same brush. I full time Emacs user but I like vim. Vimium is how I survive a web browser.
If you like a classic IDEs experience, look at Doom Emacs https://github.com/hlissner/doom-emacs or if you are familiar with vim then https://www.spacemacs.org/ Personally, I use vanilla Emacs (it has all IDE features that I use and more).
For me Emacs is the application platform, unified environment: each key press is a programmable customizable command. My favorite applications are magit (the best git UI ever created) and Org-mode (especially Org babel + jupyter-emacs — Jupyter notebooks-like environment) — all my life in a plain text. Naturally, there are lots of programming modes.
As someone who transitioned from VS Code to Vim this article really comes across as very anti Vim. Why is it you feel it’s just the older coders who are stuck using Vim because it’s comfortable? That’s not true for me and I’m sure many others. Moving to Vim for me was a choice, and I feel way more productive for doing so. I started out using Brackets then Atom then VS Code now Neovim which is far from outdated.
The article really reads to me as derogatory to those who choose anything but VS Code and the kin.
Totally agree. I started out with IDEs, and since switching to vim have tried to switch to IDEs and graphical editors like Intellij, sublime text, and visual studio code, I’ve even tried emacs (which it turns out I like better than the IDEs) but I always come back to vim (or now neovim). While most ides now have vim mode plugins, in my experience, they are incomplete, and often buggy, and sometimes they just can’t replicate some of vims features. And then there is performance. IDEs have terrible start up time, are hungry for RAM, and can slow to a crawl with large files.
This also completely ignores that modern vim and neovim, as well as emacs can have many IDE-like features by installing a few plugins.
+1
Was this article intended to be written from an objective perspective? It stinks of bias and everything mentioned as a “feature” of IDEs has been in vim and emacs for years.
Just use whatever works for you. If you’re curious then then try vim/emacs otherwise stick with an IDE. Just know that similar to vim & emacs: Atom, VS Code, Sublime are all text editors that gain IDE powers through plugins
The article is just entirely spouting off their ignorance of Vim and Emacs. They show in practically every sentence they don’t even know what it’s like to use them. They could start by listing some IDE features that V&E don’t have? Anything?… They mention code completion etc., as if that’s an example. Clueless. Do they even realize that VSCode uses LSP to provide its rich code navigation features, and Emacs uses the *exact same LSP servers* to give the same features?
I’ve lost count of how many times both Vim and popular, new, IDE users have proudly shown me features they think are awesome super special modern abilities, only for me to realize they’re excited about something I’ve been doing since the 90s in Emacs. And Emacs has not stood still in any sense, it’s *way* more powerful than it was.
You know, I’ve actually seen a trend of newer devs switching from modern IDEs into VIM.
So it’s not just old timers hanging on. It’s perceived as more efficient and professional.
I’ve never used either of the old breed IDEs for more than a few minutes at a time in Linux but I know they won’t be going anywhere.
Couldn’t agree more. Most Vim users nowadays are actually those transitioning from the “so-called” modern IDE such visual studio and so on. The author seems to miss that significant fact all together but rather describe those users as “stubborn”!
This. I started programming on Linux about two years ago, after a couple painful months of editor-hopping I had settled on Vim because it was faster and more reliable compared to numerous modern IDEs I’d tried out. This article sounds as if Vim is just a bad habit Unix dinosaurs can’t let go, while the truth is that one who looks for a stable code editor that *just works* will eventually discover Vim and most probably stick to it for life.
Will – I’m curious… Why did you decide to ditch VS Code and revert to a more primitive text-based environment? (Genuine question!) As stated below, I have recently gone the other way. I know there is something about raw text editors – like driving a manual car with the top down on a country road – but what was it in particular that turned you away from VS Code in the end?
Suppose you are asked to do a simple calculation. Say, you have to confirm that 355/113 is a good approximation for pi.
Would you refuse to work until you got Excel installed in your machine? Of course not — you could use the calculator that comes with your OS.
Vim is like the calculator that comes pre-installed in your computer and most servers you’ll have to interact with.
Sometimes you just need to edit a file. And Vim excels at that!
The fact your calling it a more “primitive” text editor tells me you have never delved that deep into vim. Vim is actually more powerful IMO then most modern IDEs out there due to its approach to text and actions. Vim has its own language, with verbs, modifiers and nouns and that simple concept translates into incredibly complex actions with very few keystrokes.
The only issue is the learning curve. I have yet to find any other IDE capable of the power of vim. Granted I’m including plugins when I discuss vim, like spf13. But the concepts at the core of vim are powerful and I wish modern IDE followed suite.
I wouldn’t necessarily call VS Code a “modern IDE”. Unfortunately, I think it suffers from being written as an Electron app in the performance department for some things, and I do end up preferring VIM over VS Code as well. However, with PyCharm or Visual Studio (the full Windows app) for me it was a whole different ball game. Although, I do use VIM keybindings in PyCharm.
Transitioned from BBEdit to vim a couple years ago. Living in the terminal is an upgrade in itself, especially with tmux in the mix.
I really enjoy not being tied to any company’s editor. A company, in the end, is always self-serving.
I’m a young developer, but I still use emacs with evil mode, I’ve used visual studio, atom, pycharm and visual studio code, even tried vim emacs extension for visual studio code, but it had a