Why I wouldn’t recommend vim (or emacs) to developers

I promised I would get back on the issue of vim and why I wouldn’t recommend it to anyone, and why (horror, shock, awe!) I find it kind of retrograde. That, importantly, doesn’t mean that everyone is not free to use it, and, to the contrary, people should use it when they are bound to console mode for some reason or another. However… 

In the previous article I made a harsh statement: there is absolutely no reason to learn vim in this day and age. In the small melee that followed, my commentators fought to show me the opposite, and I had two amazing examples that I will embed below. First one with emacs (that has been sided with vim in my rebuttal):

In this example we have emacs orgtbl mode, that will help you arrange a table in the comment part of an HTML file, even precalculate things, in a spreadsheet manner, and then generate the HTML table out of it. However, this is probably not in the common offering of the emacs editor, so it’s “pour les conoisseurs”. That is not its biggest fault though: the main problem here is conceptual: who needs to edit tables in HTML files? Who edits HTML files by hand in this day and age? We’re in the age of generated content and CSS: I find it hard to generate with said tool two types of tables in the same file, and I find it useless to generate tables in HTML files. For a developer this is a breaking point, not a selling point. For anyone else it is proof of loving the 1998-looking web. I am sure it’s useful, but we have more sophisticated tools at hand.

The second one displays the power of vim itself, the named ‘evil’. Even if it does pretty much the same thing as above, generating HTML content, it does so in a less intelligent, more appropriate manner:

I call this a more appropriate manner, and I will explain a bit later, however, note one thing: this is about learning a macro and applying it to a set of data. This is not a feature unseen in other editors, however, it has one detail extra: it knows when to stop. Whenever I record such macros in my usual editors I apply them a number of times manually because the editor is not smart enough to understand when the data ends, or where it should end.

This example has all the faults of the previous example, minus ‘it needs to install something amazing that you might not know about’, which makes vim more of an editor than an IDE.

These examples exhibit exactly what the problem with emacs/vi is. The problem is that there are features that you need to know about, and both emacs and vi require you to learn a plethora of shortcuts without any visible cues.

And I come back to the issue of vim being the same as gvim: it’s not. While gvim embeds vim quite nicely, I am still unable to get it on my cygwin distribution. And while Mihai argued that ‘cygwin is fake Linux’, I need to assure everyone that there is absolutely not a single reason why gvim would not run on Windows. Luckily, outside of cygwin gvim has an installation package that will make things work. You know what, surprisingly, works in gvim for Windows?

CTRL-C, CTRL-V. Selection using SHIFT and direction keys. Basic editing functionality, that is.

This is, of course, inconsistent across versions of vim, but it’s an amazing addition. Even the creators of gvim understand the fact that it’s a must to support basic editing functionality, as understood by most people. However, vim lacks on pure Windows the support of the GNU platform. And vim is useless without it.

The UNIX philosophy is to build tons of specialized tools. There is a high degree of flexibility that this philosophy brings, the downside being that you have to know a lot of tools. Sure, there are a lot of smart editing cues in vim itself, but most vim tricks will display some intelligent import from curl, completion done via ctags and other things like that. And some people will need that and some don’t. Most modern developers don’t, because they use an IDE, and I’ll explain some features of an IDE.

But there is always the amount of intelligence an editor can hold. Most editors of an IDE are seen as ‘dumb’ when compared to emacs/vi, because they do little more than editing and completion. vi and emacs are smart. And that’s the problem. The problem is that you have to learn a lot to grow to the level of intelligence your editor has. Vi is a savant, it does amazing things but it’s disconnected from reality.

And the reality is that vi is amazing when you have to type a lot, and generate tons of code. You know what sort of programmers generate tons of code? Mediocre programmers. The goal in modern programming is to generate less code that does smarter things. Efficient developers write 10, 20, 100 lines a day in busy days. And here I come to the place where vi doesn’t stand a chance in the face of an IDE.

While vi and gdb can work together, it’s not as glamorous as Mihai makes it. It just runs gdb in a separate sub-window. It highlights the current line. There is no watch window. There are no key bidings, you have to write stuff by hand in gdb. Here’s a session:

The problem is that most of the stuff that vi ‘can do’, they ‘can be done’. They are not necessarily practical, but they can be done, therefore they are there, the fans say. But the overhead is in fact so big that it’s impractical to anyone but the expert.

My question: Is the time invested in vim worth it? My answer: no, unless you are bound to a console in a way or another. Sure, for Linux server professionals (admins) it makes sense. Even for occasional server admins it makes sense. Does it make sense for the modern developer? Not unless you don’t have a proper IDE. And C++, C# and Java have amazing IDEs that offer a lot of features, including refactoring support, well integrated debuggers, editors well tuned to the needs of your applications (in place graphics editing, or visual editors for UIs, for example). And you also have the space of your editor properly balanced between the needs of the current state: when editing, you can see the project layout, you can also have a find-window without sacrificing too much of your editing space. When debugging, a watch window, more space for code, even split window for following code. And the IDEs keep improving. Integrated git? Even Visual Studio has that, available at right-click on the solution name. The amount of stress on my memory? 0.

While vim glorifies typing, because that’s the only thing that it can do, the rest of editors go beyond 1960 in computing and use a mouse. Certainly, some things are done faster in vi, while a lot of other things are done faster in IDEs. And I cannot find a single reason to use vi over other editor in post Y2K world.

Because in the previous mail I was subjected to vymching (lynching for saying bad things about vi, something that emacs users are accustomed to as well), I will now address the concerns of my unfairness towards vi and to state again that gvim and vim ARE NOT THE SAME SOFTWARE™. They might use similar mechanics, but as gvim for Windows shows it, no, it’s not the same. However, there were other valid concerns that I wanted to address and clarify.

First cmatei’s comment:

So, you want noobs to become experts doing expert stuff, or not ?

If they want to become server administration experts, certainly not. Let them take over the world with vi, since it’s one of the tools of trade. If not, I’d have them off my server. Make them build delivery packages, and shell scripts that will automatically fix the configuration files. Better yet, have the configurations versioned in a git repository, and they can edit with whatever they wish.

Mihai’s concern, aka my bullshit:

there’s no more VT100, everything is emulated.

But vim is thought with the limitations of VTXXX in mind. That’s what the ‘text’ in text-mode means. Sure, it’s not driven by the limitations of VTXXX in mind, and it uses graphical mode fully. To display text using monospaced fonts.

There’s no hint in this for newbies being forced to use vim/emacs and terminal

People make such harsh recommendations to beginners. That was my complaint.

«There is no real reason to resort to this sort of painful penitence,» — way to generic to be considered as being only related to newbies

Yes, it refers to everyone. Just because you get to enjoy it, eventually, doesn’t make it less painful. And yes, later I call it ‘crap’, because it is crap. Ask any person having a first contact with vi. Sure, it is smart crap, and it can be used amazingly.

vi

Notice the cursor? Up there? It’s not where you’ll start typing, actually. You’ll start typing in the lowest row, not in the highest row, if you follow the instructions to quit. This is just an example of how counter-intuitive vim is.

Why is vim a piece of crap? While it does the job, it does it like it hates you. The only piece of help you get is that opening text.

If you start editing, and press F1 you get a helpful screen. That doesn’t tell you the basic idiom of vi, which is to press ESC before typing commands like :q!<Enter>

vi-help

At this point, the user is overwhelmed. hjkl??? Are you kidding me??? Are you really using hjkl to move around? And I should know that… why?

Most unguided vi users I know quit here.

I understand them.

Vi is a piece of crap because the amount of things you have to learn to use it proficiently have not valid use outside it. While other editors try to find a common ground, that’s not the case with vi. It doesn’t need to, when bound to a console. But that is a cruel limitation for most developers out there.

Proceeding with Mihai’s comments:

«There is absolutely no reason to learn vim in this day and age.» — waaaay too generic

No, it’s a very specific affirmation. Other than the limitation of the console, there’s no reason to learn vim. And that limitation is often self-imposed; you don’t need an XServer to run X applications on a remote display, you need only X libraries installed. There is no security risk. However, remarkably, vim became an amazing tool for administrators. I salute them with all due respect, but developers don’t really need it unless they really really want to.

«you don’t need to fight with the black lacing of the scary terminal. In fact, if your work would ever require starting a terminal, the distributions already failed; » — How is that applicable to newbies in programming? When even QtCreator opens consoles?

You can, you are not forced to.

The rest of his comments were towards my mean parallel that vim is worse than Notepad. In some sense, it is. Especially when it comes to those people that quit when seeing the help screen. Of course I was augmenting the suckiness of vim by putting it side by side with Notepad, an editor it will never beat at intuitivity.

Not to beat vim too much, I do recommended where a lot of typing is involved. Not a book, editing text is crappy with vim, and it doesn’t really help there, but when you edit config files, HTML files, etc. it’s a fast alternative to any other editor. It is a nice tool, a cool gimmick, and it can do a ton of things.

Too bad its fans are such a lynching bunch. We could hear less spite, and more interesting things about it.

But the dialogue is driven by spite. I write a spiteful article towards vim and I’m answered with spite, mostly because there are no arguments. I loved cmatei’s mature intervention because it showed real cases of stuff done faster and better. Yet I don’t think it’s a reason to recommend the editor to beginners for that alone, this kind of arguments need to be brought up, not attacking flame with flame.

This article is inflammatory, I know. I will do something special for this article. From each commenter I will censor ALL comments beyond the first one, and I will answer to each such comment, without the possibility to be answered back. I do this to stop any flame from burning, because it’s my blog, and because I want the answers and possible questions to be well thought through. This is my opinion on the matter, I put a few days of reflection behind it and I am more than happy to explain why I said things I said.

And I am more than happy to note any feature that vim has and no other editor has. Other than console mode.

And please, pay attention. I said vim is crap, but said nothing on the developers or other professionals that use it. I never insult someone’s way to work, especially if that way is efficient for them. And vim can be very efficient once you know it.

Ladies and gentlemen, you have one comment. Thank you for your patronage.

Comments

Why I wouldn’t recommend vim (or emacs) to developers — 97 Comments

  1. I see you are also looking for an IDE … are these topics about you, or about new developers who would wrongly choose vim/emacs as an editor/IDE? There is a confusion here, you talk about yourself (and what you were frustrated by), but the posts look like advice for other programmers. Perhaps in some years, when you’ll see that IDEs are changing and changing, and you won’t be able to follow them, or customize things *exactly* as you want at your (then) expertise level, you will return to one of these ‘old skool’ editors. The idea is, you are bold into dismissing them, but you are also on a road, and you forget that. Basically you confuse your present frustration (if you don’t like an editor, move on) with objective advice for other people, who actually may see things very differently. This is one disadvantage of being smart, it’s easy to invent smart reasons for what you don’t like.

    • I wasn’t looking to express my opinion on VIM, I was merely trying in the previous post (linked above) to explain that recommending vim and console to beginner programmers can be disastrous, and it takes time and energy from coding itself.

      For the time being I’m quite happy with QtCreator, finally rising up to the task. Until finding QtCreator I’ve been forced to use certain IDEs due to platform restrictions that I couldn’t influence. QtCreator, however, is just fine now, and I’m happy with it.

      Yes, I see that IDEs are changing and changing. On the other hand, the requirements from an IDE in 2014 differ greatly from what we needed in 1994. Back then Borland’s C++ IDE was enough, now we need tons of stuff.

      Yes, I know, you can customize and work exactly the way you like it using old tools. How about working better? That’s what an IDE should help you do. Some succeed, some don’t. It’s a gamble, I know.

  2. Ok one comment, I hope you don’t mind its length. From uncyclopedia.org:

    “In the beginning was ed, and ed begot em. And em begot vi.
    The source code was originally written 6,666 years ago by Samuel L. Jackson with ink made of human blood. Jackson had seen the screens of the Mighty Gods: Ken and Rob and Brian and Dennis and all the rest who resided under the Mighty Bell. He watched over their divine shoulders as they produced the source code of the Universe itself in their mighty editor, Sam, The Editor of the Gods, and he wished to bring the light and power of this wondrous implement to mortal man. Jackson spent days poring over man scrolls, toiling to copy the editor’s greatness, but he tried in vain. Despite the power and elegance of Jackson’s editor, he could not copy the perfection of Sam. Unsure of the Gods’ feelings, his own skills, and mankind’s worthiness, Jackson hid the source code in a cave near the Hills of Murray, hoping that the time would come when man was ready to see this shadow of the Gods’ hallowed editor. Centuries later, the code was found by Bill Joy, who compiled the editor for Unix in the Middle Ages. Joy’s discovery led to a Golden Age of programming, and gave rise to a new breed of hacker. Spurned by the increase in productivity and godlike powers granted to these Master Hackers by the great editor, Unix and vi came to rule all the land, bringing peace and prosperity to all, as well as sanitation, medicine, education, wine, public order, irrigation, roads, a fresh water system, and public health.”

    Emacs is:
    A pretty good operating system, but it could use a better text editor.
    Short for: Eighty Megs And Constantly Swapping.
    Or maybe: Esc-Meta-Alt-Ctrl-Shift.
    GNU Emacs = Generally Not Used Except by Middle-Aged Computer Scientists.
    Recursive acronym for: Emacs Makes A$$ Crack Seemingly-Good
    Erroneous misuse of acronyms crashes systems
    More proof that RMS is fscking crazy.
    Feeble in comparison to vi, more fully-featured and yet still a POS compared to ed
    Also the name of a Microsoft Lunix virus: Emacs Makes A Computer Slow
    An editor specifically designed to cause Carpal Tunnel Syndrome. vi is considered to be a much better editor in the Emacs community. It is not necessary to know how to use Emacs in order to be unhappy, but it helps.
    Emacs was originally invented by Richard Motherfucking Stallman, so he could use it as an excuse to hate vi, KDE, Linux and pretty much everything that he didn’t invent.

  3. Dorin, I can show you many cases that IDE may not be a proper choice.

    A typical example is maintaining a big enterprise web project which dependent on many third party services and components. It takes environment support team many days to set up a staging/dev environment whose build script is some command line tool which has some legacy code written in different languages, so NO IDE project files are available unless you can figure out it by yourself.

    And even you IDE set up, you still get the job done slower than those CLI geeks simply because of the overhead of IDE.

    For example, eclipse functionality of search text in files is much slower than grep. when there are *many files* to be searched.

    IDE has its limitation because it’s designed for certain framework or certain community, so it exclude some smartest people around the world.

    • I might have agreed with you if I wasn’t working on such a big enterprise project myself, with the experience of using Visual Studio to its limits. There is no way anything of that complexity can be written with such a simplistic approach as you suggest.

      Using Visual Studio helped the team focus on components properly, merge components that needed to be merged, and while I agree that not everything is done from the IDE (automatic builds are done using TFS, of course) the whole project is IDE-centric, and all components are loaded in an IDE when developing.

      The team you mentioned has bigger problems than not being able to use an IDE. Hire a guy that knows how to do build management and automation without sacrificing convenience for the developers 😉

      In order to adapt to a new environment, yes, it will take developers more time to set-up. But that’s a toll you pay at the beginning of the project, not when the mess is created by people that don’t know better. I know a lot of people don’t take build management seriously: it is a serious issue that can endanger smaller projects than the one you named.

    • Just a few thoughts.

      As you may or may not know, Vim is a text editor thought by some people to be particularly well suited for editing code. While Vim does have some features that pertain to software development beyond editing code and while you can make it do various things, it doesn’t really try to be anything like a full-featured IDE. Criticizing Vim that is not a good IDE is like criticizing a bicycle because it’s not a car.

      While Vim is particularly good at editing code, that doesn’t mean it’s usefulness shows only when writing large amounts of code. Like I said a million times as comment to the other article, for me Vim is not about speed, it’s about comfort. It’s about thinking and having my thought translate into code almost automatically, without any annoyance or interuption. It’s like saying it’s only useful to learn touch-typing if you write large amounts of code. Can you write code by searching the keys on the keyboard and then pecking them with two fingers? Yes, you can. Is it comfortable? No, it isn’t. Is it distracting? Yes, it is. You’d have to take my word for it that Vim is actually more comfortable when writing code. I think between the two of us I’m the one who has more experience with both text editing paradigms.

      You don’t need an IDE to develop software in general. While one may be very useful for certain programming languages, not everyone codes in those languages and not everyone needs the crutch an IDE provides. As an example, on any given day I may write Python, PHP, Perl, Scala or JavaScript in any combination. To my knowlege, there is no single IDE that is particuarly good at handling all those. I could try to bend an IDE like Eclipse into shape by installing a million plugins, but it will still feel like a Java editor with plugins on top and a lot of those plugins are not very good. Or I could try to learn n IDEs but then I’d bump into one of the problems you seem to have with Vim: “The problem is that there are features that you need to know about”. And should I mention, again, that I don’t NEED an IDE to begin with? And why don’t I need an IDE? Because I make my own iDE (with lowercase “i”, because it’s probably less integrated than the typical IDE, but it happens to be as integrated as I need it to be). I type a command (something like project-{projectname}) and I get a terminal window with tmux already running and already split in a few panes with processes already running. Most of the time one pane would run bash, and another pane would be a trivial script that clones the git repository and runs the tests whenever the repository changes. This is very project-specific. For some projects I may have a pane where a development web server runs and I can see it’s console output, for some projects I may have an SQL client running in one of the panes etc. And, of course, I have gvim to the side. Or sometimes I have Vim in one of the panes (especially when I don’t need a browser, and unless I’m working with legacy code I don’t) so that I can go full screen with that terminal and not be bothered by anything else. It’s not I who have to learn new stuff when I move from environment to environment (the Windows Vim can be made to work exactly like the Linux one, but I don’t use Windows anyway) or programming language to another. This may seem retrograde to you, but this works for me better than anything else. I know what I need and I know why I need it. I don’t press F6 because I know that’s what comes after F3, I’m intimately connected with the process. I don’t know if you remember the Ruby kids of a few years ago. Every Ruby screencast or presentation showed a text editor (usually Textmate), not an IDE, and every screencast or presentation mentioned things like testing, refactoring, automated deployment and they showed little tools they made for completing those tasks. And they knew what all those tools (like rake, capistrano, puppet etc) did and why they needed them.

      You seem to have a misguided worship for “the right way” to develop software. You didn’t touch that so much in this article, but you did mention it and you also mentioned it in the other one. I think there is a time and place for hacking. I think as a beginner just learning to code hacking is ALL you should be doing. I know when I started to code I didn’t care much about Borland C++ or sound software development methodologies. What I did care about is making something that worked the way I envisioned it, that calculated the bloody roots of a second-degree equation, that calculated the way to get out of a labyrinth, the way to find the shortest path through a graph or any other challenge that the manual threw at me or any other challenge that I gave myself. If you would have bored me then with all the checkboxes in all the dialog boxes in Borland C++ or with the “right way” to write code you would have lost me there and then. Which isn’t to say that it’s important to develop “the right way”, it’s just not something a beginner should be concerned about. Hacking is also useful when writing a proof-of-concept in order to prove to yourself or to others (your team for example) that an idea would work, in order to identify pressure points and figure out what would be the path of least resistance. If you only want to invest two days in this you sure as hell don’t want the first day to be about setting up your environment and the second day about designing a class hierarchy. You want something quick and dirty. I would reach for PHP or Scala and Vim, not for Java and Eclipse. Can code for the PoC creep into the final production code? It can, and it does. That’s how multi-billion dollars companies were built. I remember an interview with a Google person. He was asked by the interviewer why Google doesn’t release the custom Linux kernel they used internally: was it about intellectual property, or were they ashamed with the quality of the code. The answer? A bit of both. Imagine that, Google was afraid of being judged by the Dorins of the world. That code is valuable not because of some arbitrary standard of quality and “right way” that you may come up with, it’s valuable according to the only standard that matters: it makes money. Other people see value in it any they part with their hard earned cash in order to use Google products. And yes, I’m sure Google cries all the way to the bank. Software development is not about writing neat code according to some method, it’s about building a software product that solves a specific problem. Do you remember, back in the day, how the Google search results looked like compared to the like of Altavista or Lycos? They didn’t achieve those results by worshiping the code-writing methodology, they achieved it by worshiping the problem. And anyway, “the right way” depends a lot on the problem you’re solving. Do you make a tool for yourself to do whatever? Do you make software for financial transactions? Do you make software for space exploration? Do you make software for defense projects? Each problem has its own standards and not everyone is solving the problems you’re solving. Somebody could tell you that you don’t develop code “the right way” because you don’t give the mathematical proof that your algorithms are indeed correct.

      P.S. I understand you didn’t refer to me specifically in this post.

      P.P.S. This comment is rhetorical. Please don’t answer.

      P.P.P.S. This comment is a pamphlet. Not a single word of it is true.

      P.P.P.P.S Even though I may have used the word “you”, or even “Dorin” in this pamphlet, I didn’t specifically refer to you. I used them as generic person-placeholders. Please don’t take it as a personal attack.

      P.P.P.P.P.S. While it may seem, at a superficial look, that this pamphlet has anything to do with the post above, it’s not meant to and it doesn’t. It was actually typed by a million monkey banging on a million typewriters. Even the fact that the words tie into sentences is a coincidence. As such, it may be deleted without regret.

  4. Whatever dude, use your own IDE and write your own code and refactor it your own way. I’ll use mine and let the haters hate.

    PS: I stopped reading at 20% of the article when I realized you only picked up the comments from the last post and countered them — sometimes with forced exaggerations.

    PPS: Don’t bother to comment, I don’t think I’ll read this anymore. Except for having some fun from time to time. Maybe Fun (Haskell:P)

    http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/

  5. Now that’s something constructive. Serios, am nevoie de voi nu să vă supărați pe mine, ci să îmi spuneți clar ce face vim să fie mai bun ca altele. Niciun utilizator de vim nu m-a convins pînă acum, deși știu foarte bine că vim poate fi mișto. Dar pur și simplu nimeni nu poate să îmi explice de ce.

    • Ah. Citind articolul n-aș fi crezut că ești atât de sincer interesat. Să te conving că Vim e mai bun? De ce? Uite ceva la care poate nu te-ai gândit: eu însumi nu recomand Vim nimănui, fie el începător sau nu. Vim e acquired taste. Unora le place, unora nu. Dacă unul din colegii mei stă lângă mine în timp ce programez și e intrigat de ceea ce vede și curios o să-i zic: e Vim + tmux + whatever. E ceva ce-mi place MIE și îmi e MIE util. N-am comentat ca să te conving pe tine de ceva, am comentat ca să-ți spun care-i părerea mea și să mă ofer ca contra-exemplu pentru afirmația că nimeni n-are de câștigat dacă folosește Vim „în zilele noastre” în loc de Notepad++. Eu consider că am de câștigat, big time. Dacă chiar vrei să vezi ce-i atât de special la el nu trebuie decât să-ți dai interesul să-l înveți și să-l folosești.

    • Eu am folosit nano și geany/gedit în primul an de Linux / Notepad++ pe Windows. Apoi am trecut pe Linux only și am geany cam 6 luni. După, am văzut pe cineva folosind Vim și m-a atras.

      Etapa 1: Stăteam mereu în insert, foloseam doar câteva comenzi, când mă frustram că nu-mi iese ceva (copy-paste ca lumea să nu indenteze aiurea, etc) ^Z, deschideam cu gedit, îmi făceam treava aia frustrantă, mă întorceam la Vim și dădeam ok să reîncarce bufferul. Apoi am dat de o prezentare de Vim la cdl, aceeași persoană.

      Etapa 2: Știam să folosesc acum Vim și navigare în modul normal și puțin macro-uri. Dar le foloseam pe principiul când ai un ciocan totul ți se pare un cui. Până am dat de articolul la care am dat share deasupra.

      Etapa 3: Timp de cam un an luam în fiecare zi câte ceva nou despre vim ca să testez. Nici acum nu știu toate lucrurile din el și nu cred că o să le învăț dar pot zice că e un editor la care n-o să renunț.

    • Acum folosesc mereu doar Vim. Inclusiv pentru editat cod Java unde cei mai mulți consideră că ai nevoie de IntelliJ.

      Singurul caz în care aș mai folosi un IDE acum ar fi dacă el ar face editare la nivel de AST

    • Te descurci fără IntelliSense/J/whatever? Are sens să-ți aglomerezi mintea cu N mii de API-uri?

      Ce faci în momentul în care ai o mulțime de clase mici?

    • Mă disciplinează să am cod mai modular și cu mai puține clase.

      Also, folosesc splits și folds destul de mult ca să am toate clasele relevante pe ecran. Și Javadoc dar din browser 🙂

  6. First, org-mode is part of the emacs distribution for a long time and it tends to have a bunch of vocal followers (because it’s awesome) so it’s hardly obscure. Second, you ask who edits HTML by hand. Back in the day when I was freelancing, I used org-mode to keep track of things. And yes, I was editing (LaTeX, not HTML) tables by hand to generate invoices. YMMV for sure, but this exact feature helped me a lot – this is a coincidence, I was only looking for the kind of smarts you get with vim/emacs but not with other editors.

    I guess this whole debate is about where you draw the line in “worse is better” http://dreamsongs.com/WorseIsBetter.html. Your line seems to be quite a bit on the “worse” side (simplicity).

    • Hmmmm, I will have to write a follow-up with “things I learned by disagreeing with text-mode editors fans”. This gets more insightful by the minute. 🙂

  7. Came to read about vim, got some practice with Romanian!

    I agree that vim and emacs have much too steep a learning curve for some people. It’s the age old GUI vs shell console mentality.
    Sure the command line shell can be ultimately powerful, but often GUI doesn’t need you to think too hard to do 90% of what you need.

    I use Visual Studio, eclipse and plain old UltraEdit or Kate. As long as you can record macros, most tasks are trivial. The Visual Assist plugin for VC++ is brilliant, and makes coding really easy. In extreme cases, one can edit the VS macros in VBScript and do all sorts of magic.

    vim and emacs may be great, but it depends on the user. Just because Gurus use them doesn’t make them the best possible. By that logic we must give up C++ because Linus thinks it sucks.

    I don’t even touch type, it’s a useless skill – if your typing speed is a factor slowing you down, you need to write more complex code!

    • I hope that honing your skills in Romanian would do good to you in the long run, there are studies made that learning a new language helps 🙂

      Linus thinks that C++ programmers suck, and I agree with him. Maybe he points it towards the language, but it’s obvious that the programmers are more of a bother.

      Indeed, for a developer typing speed is not a factor. That’s why I see the advantages of ‘being to add text faster’ as moot points. However, being expressive while assisted by your editor is important, and if Kate, UltraEdit or vim do that, then that’s perfect.

  8. never learn on an IDE. lots of magic happens plugging in stuff and when something goes wrong good luck tracing it

  9. Oh, this again… You should realize one thing, VIM is not necessarily about the SPEED. It’s about saving you from frustration when you hold the arrow key and wait for it to come close to the position you want to release the key. All repetitive imprecise actions eat up the energy.

  10. Lol. My IDE in vim starts in 0.5 seconds. I get all the autocomplete I can, error correction on the fly (from YouCompleteMe addon), I barely have to type. I can jump to definitions which don’t require slow parsings like in visual studio (clang based) and jump back in a snap. I can jump to any file in the project typing a few letters. And the most important – I do this on 15.6 laptop with plenty of space to see the code. Can you do that with an IDE without cluttering your enviroment? No, you need a new monitor.

    Oh, and by the way, once cent, you’ll NEVER, I repeat, NEVER be as productive in your clunky IDE (whatever it is) versus someone who’s skilled in vim. It just won’t happen.

    Is it worth learning vim? Unless you’re a jealous loser who can’t admit coding with vim is a lot faster, it is totally worth it. See ya.

  11. I’ve been using vim for about three months now, and I love it. I’m so much more productive than I’ve ever been in any graphical editor or IDE. I can go exactly where I want to go in my project, and change exactly what I want to change, the moment that I decide to do so. It’s so simple and comfortable, and there’s no fumbling about with the mouse, like I used to have to do in Geany. I wouldn’t say that vim is the best editor, it has plenty of flaws (for example, not the best indentation support, vimscript is a terrible language, etc), but I would say that vim is the best editing experience that I’ve ever had. I think vim is something special.

    “These examples exhibit exactly what the problem with emacs/vi is. The problem is that there are features that you need to know about, and both emacs and vi require you to learn a plethora of shortcuts without any visible cues.”
    This isn’t a problem with emacs or vim. This is an unfortunate, but necessary, side-effect of any program with a lot of features, including all IDEs. I’ve used Eclipse in school for years, and I don’t know about the majority of the things it can do, because 1. it doesn’t tell me it can do those things, and 2. I haven’t bothered to research it. Exactly the same is true for vim. I suppose by ‘visible cues’, maybe you mean the ridiculous collection of menu items strewn all over the place, but browsing the menus in an IDE is honestly no less difficult than browsing vim’s :help. Also, you don’t need to learn all the shortcuts to use vim or emacs, just as you don’t need to learn all the features of an IDE. I started in vim with just the arrow keys and a couple of useful commands, but over time I’ve learned the rest and committed the entire keyboard to muscle memory. If you just know the basics, you’ll be just as fast or productive as you are in any other editor or IDE, but the more you build on that, the better things get, over time. No pressure, though.

    “CTRL-C, CTRL-V. Selection using SHIFT and direction keys. Basic editing functionality, that is. This is, of course, inconsistent across versions of vim, but it’s an amazing addition.”
    The reason this inconsistency exists is because vim was designed to run in a terminal, and in a terminal those keys do entirely different things. ctrl-v lets me type control characters, ctrl-c kills the running program, etc. When someone uses ctrl-z in most programs, it’s the undo function, but when I use ctrl-z in vim, my terminal switches vim to a background process. That’s an important feature that I use a lot, so I’d rather not bind anything over it, and anyway, vim’s default ‘u’ for undo is a lot more sensible and a little easier to press, so there’s that.

    “The problem is that you have to learn a lot to grow to the level of intelligence your editor has. Vi is a savant, it does amazing things but it’s disconnected from reality.”
    This isn’t a problem with vim, as much as it is a natural law that applies to everything. The more complex a tool is, the more you have to learn about it in order to use it effectively. This is true about any good editor or IDE, not just vim. Hell, it’s true about any program, and it’s true about computers in general. And it’s not that vim is disconnected from reality. Vim just favors internal consistency and simplicity over similarity to other tools, and chooses the former wherever those two things are mutually exclusive. And in the long run, that’s a good thing.

    “And the reality is that vi is amazing when you have to type a lot, and generate tons of code.”
    Not really. When you have to type a lot, you have to type it, regardless of the editor you’re using. I guess what you mean is ‘vim is amazing when you have to type or edit a lot of things that are very similar to each other’, in which case, that is true, but there are plenty of other tools that are just as good at that. That’s not specific to vim. No, vim’s greatest strength, other than key chords, is text objects. Vim really is amazing at any point where you need to edit code, and this is because vim thinks about the code in the same way the programmer does: in terms of words, paragraphs, things in parentheses and brackets and braces and quotes, xml tags, all of these things are text objects. Therefore, making the editor do things to your code takes a lot less effort, because you get to skip the step of deciding which characters on the page represent which thing you want to change, and the step of selecting those characters manually. You can’t be off by one character, there’s no need to be precise with the cursor, you just type what you want and go. No text editor works by reading your mind and changing things as you think about them, but vim is closer to that idea than any other editor in existence. That is the power of vim.

    “While vim glorifies typing, because that’s the only thing that it can do, the rest of editors go beyond 1960 in computing and use a mouse.”
    Vim is a text editor, it doesn’t use a mouse because it doesn’t need one. Text is much easier to type with a keyboard than with a mouse, and in vim it’s just as easy, or easier, to navigate with the keyboard as opposed to the mouse. At this point, the choice comes down to whether you’d rather spend a little time now learning the key bindings, or whether you’d instead rather spend the rest of your life constantly switching between the keyboard and mouse, moving your arm back and forth all the time, and breaking your concentration on the work that you’re doing in order to switch your mindset between input methods. Many people think the latter is acceptable, and those people shouldn’t switch to vim. The rest of us have a good reason to use it and are glad that it exists.

    “But vim is thought with the limitations of VTXXX in mind. That’s what the ‘text’ in text-mode means. Sure, it’s not driven by the limitations of VTXXX in mind, and it uses graphical mode fully. To display text using monospaced fonts.”
    How is that different from any other editor or IDE? They all display text using monospaced fonts, and that’s all they do, no matter how much you pretty it up. I think the point was that emulated terminals don’t have the size constraints imposed by the VT100. In your original post, you said “So why should people learn the complicated way of editing multiple files in a 80×25 grid?”. It sounds to me like your complaint is about the size of the terminal, not its graphical capability. That size constraint doesn’t exist anymore, though. When I run vim in a terminal emulator I can split the window into six separate panes and edit six different files at once, and each pane will still be larger than a VT100. So I don’t think your complaint about it being text-mode is valid.

    “Just because you get to enjoy it, eventually, doesn’t make it less painful.”
    It wasn’t painful for me, I enjoyed every minute of learning vim. Every new thing I learned was an easier way to do something I’ve spent years dealing with in other editors. I don’t have to move my hand all the way to the arrow keys or the mouse to navigate now, that’s an improvement. I don’t have to fumble about with menus and form windows and things just to do a regex replace or create a macro, that’s an improvement. Yeah, some things are different from what you’re used to, but not much is worse, and most things are different for a good reason. The only reason this would be painful is if you didn’t care enough to want to learn it in the first place, in which case I don’t recommend you switching from whatever editor you’re already comfortable with anyway. And vim does its best to make learning it as painless as possible. Most of the basic commands do simple things, and are bound to keys that are the first letter of a word that describes the command, and most of the complex commands are just combinations of the simple ones, so you never have to learn those at all, you can just use them.

    “Notice the cursor? Up there? It’s not where you’ll start typing, actually. You’ll start typing in the lowest row, not in the highest row, if you follow the instructions to quit. This is just an example of how counter-intuitive vim is.”
    Really? I think this is actually good design, as it showcases an important feature of vim: the command bar. This behavior makes it clear that when you type a ‘:’, it puts you in a special area where you can do things like quit the editor, call up help, open files, etc. Anyone familiar with the command line, or even just with chat consoles in video games, will immediately recognize this for what it is. And honestly, it would be much more counter-intuitive if commands showed up where the cursor is initially – i.e. in the body of the document you’re editing.

    “Most unguided vi users I know quit here. I understand them.”
    I do too. Vim is not the easiest thing to just pick up and use, you need to be patient and spend some time reading about it first. You need to be guided a little. That doesn’t mean vim is unintuitive, though. Mice are intuitive, but when my mother learned how to use one, she had more trouble than the average person starting with vim. Powerful tools require some form of complexity, and complex tools take a little time and effort to learn how to use. For me, it was well worth the effort. If the same isn’t true for you, then don’t use vim. Nobody’s forcing it on you. But at the same time, realize that your idea of what is and isn’t worthwhile effort is not necessarily going to be the same for everyone else.

    “Of course I was augmenting the suckiness of vim by putting it side by side with Notepad, an editor it will never beat at intuitivity.”
    Notepad isn’t intuitive, it’s just very simple. A microwave is easier to use than a smartphone, not because it’s more intuitive than one, but because it can’t do as much to begin with. The problem here is that programmers need particular features to code comfortably, and Notepad does not support any of those features. This is why, for example, every text editor that supports syntax hilighting is better than every text editor that doesn’t, regardless of all other considerations.

    “Too bad its fans are such a lynching bunch. We could hear less spite, and more interesting things about it.”
    While this can be true to some degree, I don’t think it was the case here. I think the reason you got so much spite was entirely because the article you wrote was so spiteful, and the reason you didn’t get as many actual arguments is because you didn’t put forth very many. You would have gotten the same reaction regardless of the topic of the article. You would have gotten more positive and constructive feedback if you had actually put in the effort to learn about the thing you were trying to criticize before trying to criticize it. On the other hand, there is a flame war between vim and emacs, and I kind of wish that wasn’t the case. Both vim and emacs are wonderful in their own ways, and they both have their own sets of problems, and it would be cool if, instead of arguing about which is better, both sides took the time to have a proper discussion about it, and learn from each other. Maybe then they could work together to make both editors better.

    “And I am more than happy to note any feature that vim has and no other editor has. Other than console mode.”
    One thing in vim that I’ve never seen in any other editor ever is the undo tree. In most editors, undos are kept in a stack, so if you undo changes, and then make more changes, it erases the original changes forever, and you can’t redo them. In vim, undos are stored in a tree, so you can always go back and redo things, no matter what. I think this is an incredibly useful feature at times, and often an overlooked one.

    As much as I love vim, I agree that it’s probably not the best editor for people who are new to programming, or people who just want an editor that does the job. I only recommend it to people who know what they’re getting into, and are willing to invest the initial effort so they can benefit from a smoother coding experience later. I’ll recommend the Dvorak keyboard layout to the same people, but not to the people who just want to be able to type and don’t care how easy it is on their hands in the long run. Vim is the best option for some people, emacs is the best option for others, sublime for others, etc. Everybody has different needs and preferences, so everybody is going to have a different editor that best fits their needs and preferences, and I don’t think that should be judged. If your preference is that you want something that you don’t have to learn, and something that you’re going to be immediately comfortable with, then don’t pick vim, because it’s not for you.

    I get the feeling that your original article was meant to express something along the lines of: ‘vim has a high learning curve, I’m sure it’s great for a lot of people, but if you try to get noobs to use it, it’ll just leave a bad taste in their mouth and not much else.’ This is a very real problem and it makes perfect sense to write an article about it, and judging by your responses in the comments it seems like that’s what you were going for. However, whatever your intentions were, it sounded as if you were actually saying something like: ‘vim is terrible, it has no worthwhile qualities whatsoever, nobody should use it for any reason … therefore, we shouldn’t recommend it to noobs.’ This is a rather stupid thing to write an article about (vim wouldn’t be so popular if it were actually as bad as you make it out to be), and it’s inflammatory for no reason that I can see, and it can be considered very rude and offensive. I’ll give you the benefit of the doubt and assume you were going for the former, and are just really bad at explaining yourself, or something like that. Anyway, I like vim, and it is excellent in a lot of ways, and I think that’s worth saying, at least.

    • Thank you for your in-depth answer, it was very useful to read it. Your answer is, indeed, valuable, but there is one point that is missing.

      The point is: I wrote this article because people were recommending vim to beginners. I do understand the fact that vim is or can be a great tool (in the end, the tool is as good as its handler). It is not a great tool for the general public because some of the reasons I enumerated there.

      But I was aggravated by the vim mob explaining how much I suck for even not recommending vim to beginners. I came to say that the vim people are a lynching mob after I was lynched myself. This is not my first time with this topic.

      What vim doesn’t have and every IDE has is integration and project view. Support for small refactorings across files. If vim has such features they are well hidden and, probably, the won’t work for files that you haven’t opened yet.

      You complain about me being unjust when it comes to monospaced fonts. It’s not only that. An IDE can do a lot of things, even font preview or image preview. You can check out resource files. You can see a lot more things. Of course, it is all up to the IDE, but still.

      I do like the idea of undo-redo trees, and I find it particularly useful for an editor that can give you so little information. I don’t think it’s a feature I like, and I like git more for version control. I think not relying on the editor for greater changes and relying more on small increments is overall better for my code.

      I would never recommend to anyone working without an IDE. I still think it’s a shortsighted way to do things, and I believe that vim can be preferred over an IDE only when you can assume the cost of 1k+ lines file. The code also becomes unreadable… but that’s just my experience, ymmv.

      All in all, Notepad++ is a better choice than vim. The comparison with Notepad was only made out of spite, but Notepad++ is an honest-to-God better choice than vim.

  12. I’ve used quite a few IDEs, and they’re just not for me. They’re too complex, they do too many things for you. I like to have a little more control over my environment than that. I suppose you could say that the terminal is my IDE, since that’s how I access all of my tools and things.

    You’re right, vim isn’t an IDE, but it can be configured to behave like one. There are plenty of plugins available that you can mix and match, to give vim pretty much any and all features you might want it to have. For example, NERDTree and TagBar will display your project’s directory tree and taglist (respectively) in a sidebar, Syntastic will mark syntax errors automatically for you, Fugitive provides fantastic git integration, etc. I’m not saying that vim should replace the IDE of course, I’m not saying that at all. What I am saying is that vim can do anything with the right plugins, and therefore, there’s no use in judging it based on what features it has or doesn’t have. It just becomes a moot point.

    Don’t misunderstand me, I never meant to imply that the undo tree should be used as a replacement for proper version control, that would be ludicrous. The undo tree is pruned constantly according to how much memory it’s using, and by default it doesn’t persist across vim sessions. All I meant when I mentioned it was that, if you undo some changes temporarily and then change something else, you can still redo if you need to, those changes aren’t lost forever like they are in other editors. But this is on a scale of changes over the course of a few minutes or so, not the sort of changes you would track with git.

    Again, I’m not a big fan of IDEs. I think they overcomplicate things, it’s easy enough for me to manage projects (even big ones) directly from the terminal, and all that gui stuff just gets in the way. That’s just my personal preference though, if IDEs work better for someone else, more power to them. I don’t really see how file length factors into this though, but I will say that line count means nothing if you don’t consider the language the file is written in. XML files in particular can get rather large, through no fault of the programmer and with no regard to his skill level.

    Notepad++ is definitely one of the editors I tend to recommend, and it’s the only editor I recommend to Windows users (although Sublime will probably be another, once I’ve used it for long enough to form a proper opinion of it). I don’t agree at all that it’s a better editor than vim, it’s not nearly as extensible and it doesn’t have any of vim’s specific features. However, it does everything a code editor needs to do, and it’s similar to other code editors, and that makes it the better option for beginners and other non-powerusers. So in that sense, yes, it is a better choice for the average user.

  13. Not just for me. Vim is the right editor for a lot of us. And it is objectively an excellent editor, because it is objectively excellent at code editing, however flawed it may or may not be in other ways, and whatever anyone’s opinions on it may be. And while that doesn’t mean I think everyone should use it, or that it’s a good option for everybody, it does mean that I think it really doesn’t deserve to be marginalized.

    I think what’s really grinding my gears about this is your apparent view that ‘I don’t like vim, therefore vim is inherently a failure as a tool’, which is simply not the case. The only concessions you’ve made against this view so far are ‘it’s a cool gimmick’, ‘it’s good for mediocre programmers’, and ‘it’s good if you’re in ssh and you can’t make a xorg connection for some reason I guess’, and that really doesn’t do vim justice at all. Vim is good for anybody and everybody who is willing to learn something new, and every single one of those people will benefit from it. The rest of you have your own reasons for not using vim, and that’s terrific, more power to you. I guess what I’m saying is, just because vim may not be the right editor for you, doesn’t mean it’s a bad editor.

    “And please, pay attention. I said vim is crap, but said nothing on the developers or other professionals that use it. I never insult someone’s way to work, especially if that way is efficient for them. And vim can be very efficient once you know it.”
    Then it’s not crap, is it? If it makes its users more efficient at coding (which is the entire purpose of a code editing tool), then it clearly does its job well. A tool is only a bad tool if it fails to achieve its intended purpose, and that is absolutely not something that can be said about vim.

    If you have an informed and valid criticism about vim, then by all means, write an article. If you truly have concerns about introducing vim to new programmers, then by all means, write an article. If you’re pissy about a particular group of vim users calling you names on the internet, then by all means, write an article. But if you’re going to write an article that claims to be about introducing vim to new programmers, but immediately devolves into petty railing against the entirety of vim’s supporters and even vim itself (rather than the particular group of vim users you actually have a problem with), and ends up completely alienating and insulting your readers, then don’t bother writing an article.

  14. I don’t see your opinion anywhere in this article, all I see is assertion of fact. If you don’t understand the difference, I’ll give you an example:
    ‘I don’t like vim because I feel overwhelmed by the number of differences between it and the editors I’m used to, and also I’m afraid of the terminal’ is an opinion.
    ‘vim is a piece of crap because the number of things you have to learn to use it proficiently have no valid use outside of it’ is an assertion of fact, and an incorrect one at that.
    This about sums up both of these articles, actually.

    Also, I seriously doubt this article is well-informed, and I know for a fact that the previous one wasn’t. To have an informed opinion about something, you have to be at least somewhat familiar with it, which in the case of vim means that you have to have used it for at least a few months and become at least somewhat proficient in it. Any opinions people have before they reach this point tend to be really very ill-informed, in my experience with talking to those people anyway. And any assertions of fact people tend to make before they reach this point tend to be incorrect as well. Which is what tips me off that this article is probably not well-informed.

  15. “Why I wouldn’t recommend vim (or emacs) to developers
    Posted on January 19, 2014 by Dorin Lazăr”

    “Dorin Lazăr on January 14, 2014 at 15:14 said:
    Wasn’t CTRL-V ‘paste’? Oh, wait, how does ‘paste’ work?”

    Maybe you use vim now, but you didn’t when you wrote this article. Or if you did, you were extremely new to it, since clearly you didn’t know how to copy/paste yet.

    “There is absolutely no reason to learn vim in this day and age.”
    “Why is vim a piece of crap?”

    “I use vim on a daily basis”
    You changed your mind about it since you wrote this article, then?

    “All in all, Notepad++ is a better choice than vim.”
    You wrote that today, so apparently not.
    So now I’m just confused … if you think vim is so worthless, why do you use it every day? Why aren’t you using Notepad++, or one of your IDEs? If it’s just on your personal projects then you’re obviously not being forced to use it, so what gives?

  16. I use it as a ‘fast editor’ for quick stuff. When I don’t have a big project, and I want to test some code snippets, it’s easier to just take out vim in the Linux VM.

    What I write there comes out of experience. Yes, vim is a piece of crap, but it’s fast enough and it’s a sensible editor for the Linux environment. It’s not really so useful in Windows, and I tend to use Notepad++ on Windows. But then again, Windows is a bad development environment.

    Are you confused? I loathe vim, but I don’t know any faster alternative. I loathe vim from experience.

  17. “Yes, vim is a piece of crap, but it’s fast and it’s a sensible editor … Are you confused?”

    Yes, I’m pretty confused. By ‘fast’ do you mean startup time or editing time? Because the only editors that I know of that are slow to start are IDEs (which is one reason I don’t like IDEs), and as far as editing time is concerned, any editor that uses a mouse should be fast enough for your needs. I assume you’ve tried Geany, is there something wrong with that editor? It’s basically a Linux Notepad++. Geany was my editor of choice for years, until I switched to vim.

    If vim is so sensible, then why do you loathe it? What exactly is wrong with it? I know you supposedly already answered that question in your articles, but frankly, here’s a list of everything either of your articles actually say:
    – ‘People who like vim are elitist, spiteful, lynching assholes’ (which is a complaint about a group of people, not about vim)
    – ‘Vim is difficult to pick up if you’re an impatient noob who doesn’t know what you’re doing’ (which is a complaint about the tools used to teach vim, not about vim)
    – ‘Terminals are pointless and should never be used because we have mice now’ (which is a complaint about terminals, not about vim)

    But, if you’ve used vim for so long, and you loath it from experience, there must be something about vim itself that you don’t like. Right?

  18. Vim is sensible for a certain environment, as I explained. It’s easy to misquote by using only fragments.

    Yes, terminals are pointless (everywhere but in a Linux environment).
    Yes, vim is difficult to pick up.
    Yes, vim users are elitist, spiteful and inclined to lynching non-vim users.

    And yes, there are some things about vim itself that I don’t like. I wonder if I ever wrote a full article about how much I loathe vim and how bad it sucks.

    • Read the articles. Seriously, they are exactly about the things I hate about vim. But if I think about it, I haven’t stressed enough how annoying vim users can be while vymching people.

  19. Okay, I’ve reread the articles. I continue to stand by what I said earlier today:
    Here’s a list of everything either of your articles actually say:
    – ‘People who like vim are elitist, spiteful, lynching assholes’ (which is a complaint about a group of people, not about vim)
    – ‘Vim is difficult to pick up if you’re an impatient noob who doesn’t know what you’re doing’ (which is a complaint about the tools used to teach vim, not about vim)
    – ‘Terminals are pointless and should never be used because we have mice now’ (which is a complaint about terminals, not about vim)

    And so I ask again: What is it about vim that you loathe so much? This has nothing to do with its users, you don’t have to interact with vim’s users when you use vim. This isn’t about the learning curve, since you claim to be past that already. This isn’t about it being in a terminal, because you can run gvim which isn’t in a terminal, and both gvim and console vim have full support for the mouse if you enable that option. What I am asking is, while you are using vim, what things does it do that annoy you so much? What is it about vim itself that you don’t like? If you have already answered this question in your articles, and I just missed it somehow, please point it out to me. Otherwise, please answer my question, because I fear that this entire conversation has absolutely no value otherwise. I’m not trying to ‘vymch’ you, I’m only trying to turn the conversation in a constructive direction.

  20. 1) I loathe the fact that everything is so difficult to do with vim, even the simplest tasks.
    2) I use it because I need something that loads fast in the current location in the terminal. That’s why I use it.

    Back to #1: I hate all the things I enumerated there. But mostly, I hate the users. They are so insistent like they found God and are now going door to door to spread the word. I hate the fact that they recommend vim to beginners that become overwhelmed by the idea of programming just because they can’t do it in a proper environment. And I hate the fact that I have to explain over and over again the same things.

    Vim is a great choice. If that’s your tool of trade, that’s perfect. Use it. My opinion is that vim has some great ideas that I would love to see implemented in a proper editor. Until then, in my opinion, vim is a joke for anything beyond one file and 10 lines of code.

  21. “I loathe the fact that everything is so difficult to do with vim, even the simplest tasks.”
    Like what? From my experience, everything is easier in vim than it is in any other editor … that’s the main reason I like it so much.

    “I use it because I need something that loads fast in the current location in the terminal. That’s why I use it.”
    Have you tried nano? That’s a nice and simple terminal editor.

    “And I hate the fact that I have to explain over and over again the same things.”
    You don’t have to explain the same things to me, I’ve already agreed with you a hundred times that the people who try to shove vim in everyone’s faces are dicks. But that’s not a reason to dislike vim, and it’s not a reason to dislike vim’s users, it’s only a reason to dislike people who try to shove vim in other people’s faces.

    “Vim is a great choice … in my opinion, vim is a joke for anything beyond one file and 10 lines of code.”
    I still can’t wrap my mind around this … do you think it’s a good choice or do you think it’s a joke? Normally people tend to pick one or the other, no?

    “My opinion is that vim has some great ideas that I would love to see implemented in a proper editor.”
    I agree with this completely. As I’ve said before, vim isn’t as good as it could be, there’s a lot of room for improvement. There’s a project called Neovim that’s trying to be that, but it’s still in really early beta. But I’m keeping my eye on it, and my hopes up.

  22. Thanks for the hint with nano, I think I will switch to it 😉

    I shall enumerate the things that are difficult in vim that are easy in an IDE. These are things I repeated too many times, and I won’t really answer to yet another “but what do you dislike”:
    1) Copy/Paste.
    2) Navigation in the file you’re editing.
    3) Searching for something marks it and never removes the marking. I have to search for something else to remove the marking.
    4) All those amazing features of the editor require a million add-ins that if you don’t know about you’ll never be able to use.
    5) The inability of the editor to communicate me if I can edit or not.
    6) The fact that I can’t see all the things that the editor can do in a clear, simple manner. Menus are a clear, simple manner, and shortcuts can be defined for menu items.
    7) The lack of configurability, or the apparent lack of configurability. I have no idea if vim can start in ‘insert’ mode directly.
    8) The fact that I have to fill my memory with useless information unusable in other places, just to get things done in vim.
    9) The fact that it cannot send me to the definition of a symbol, nor can I see easily all the occurences of a certain word in a single file.
    10) The stress induced on my memory for keeping all the features vim can have in mind.
    11) The users.

    And these items only scratch the surface. And about “vim is a great choice”, stop cutting the context from there. The context is: “If that’s your tool of trade, that’s perfect.”. I’m not putting myself in the face of your happiness. But the fact that you spend so much energy trying to discuss about your editor with someone else shows the #11 and, I can say, the premier issue of vim: “the users”. For example, you don’t realize how aggressive your attitude was so far, and I bet you think that you were reasonable. But, as I said, all these things I listed above are already said, and I’m tired of saying them; plus, the vim users should know them by now if they are honest with themselves.

  23. “Copy/Paste.”
    ‘ctrl+c’ and ‘ctrl+v’ require pressing an extra modifier key as opposed to just using ‘y’ and ‘p’ … also ‘y’ and ‘p’ are much more natural (what does the letter ‘v’ have to do with pasting?) … either way, there’s nothing complex about it, it’s just pressing a simple key combo in both situations, so I can’t imagine how either one could be considered ‘difficult’ … if you really hate vim’s keybindings that much, you can change them as much as you like. For example, putting this in your vimrc:
    nnoremap d
    nnoremap y
    nnoremap p
    This will put cut on ctrl+x, copy on ctrl+c, and paste on ctrl+v. You can do this with anything, any sequence of keys mapping to any other sequence of keys, in any combination of modes. I’ve never seen this anywhere else, and it’s one of my favorite things about vim.

    “Navigation in the file you’re editing.”
    Really? This is the easiest thing in vim. There are lots of keybindings for navigating to just about anywhere in your file, usually in only two to five keystrokes. Here’s a list of some basic ones:
    http://vim.wikia.com/wiki/Moving_around
    I guess it is a lot to take in (which, as we agree, is the main reason this kind of thing shouldn’t be recommended to people who aren’t patient or willing enough to learn it), but if you learn one or two of them at a time, and commit them to muscle memory as you go, it’s actually pretty easy to pick up. And by the end of it all, you end up being able to navigate much faster than you ever could with a mouse. I don’t know, maybe I don’t mind because I’m used to it … I grew up with the Ultima games and a lot of other old DOS games that had every key on the keyboard bound to a different action, so to me, learning vim just felt like learning to play another video game (actually, there’s a game called Vim Adventures that’s built around that concept). I guess it makes sense that it would be annoying to someone else, though. So yeah, I guess I can see where you’re coming from, with this one.

    “Searching for something marks it and never removes the marking. I have to search for something else to remove the marking.”
    ‘:nohl’ clears search hilighting. I have it bound to the tab key in my vimrc, like so:
    nnoremap :nohl
    Now I can just hit the tab key to remove search hilighting. But you can bind it to any key or key sequence that you want. Or you could do something more complex with it, it doesn’t matter.

    “All those amazing features of the editor require a million add-ins that if you don’t know about you’ll never be able to use.”
    That’s why you take the time to find out about them. There are plenty of blog articles and websites and things devoted to useful vim plugins, or you can look for something specific that you’d like to have, and it’s never more than a google search away. This is like saying “Python has too many features and there’s no way you could possibly use them if you don’t know about them.” That’s why you take the time to research so you can know about them. Sorry, but this complaint is about the laziest thing I’ve ever heard anyone say. Also, I think plugins are a really good idea. I think I’d rather have to search google for a plugin I want, or write it myself if someone hasn’t already, if the alternative is ‘oh, this doesn’t come prepackaged with the editor? I guess you’re screwed then’.

    “The inability of the editor to communicate me if I can edit or not.”
    What do you mean by that? If the file is read-only, by default it should say [RO] down next to the filename, I’m pretty sure …

    “The fact that I can’t see all the things that the editor can do in a clear, simple manner. Menus are a clear, simple manner, and shortcuts can be defined for menu items.”
    Vim can’t do this because its abilities are more complex. You can’t just click a menu item to do something, because it can usually be combined with other things you can do to create complex actions. If you want to see all the things vim can do by default, at least as far as basic editing is concerned, there are plenty of web pages that list all the default keyboard mappings or useful commands. And of course there’s always :help, which will tell you everything you’d want to know.

    “The lack of configurability, or the apparent lack of configurability. I have no idea if vim can start in ‘insert’ mode directly.”
    Vim is probably the most configurable editor in existence, except perhaps for emacs. To start in insert mode, add the following to your vimrc:
    autocmd BufRead,BufNewFile * startinsert
    This means “automatically run the following command (start insert mode) any time a file is read into a new buffer, or a buffer is opened with a new file” which is probably what you want.

    “The fact that I have to fill my memory with useless information unusable in other places, just to get things done in vim.”
    Don’t you have to do this for anything? There are entire university courses on how to use Microsoft Excel, and most of that information isn’t useful anywhere else. Every program has concepts that are only applicable to that program. If there was a program for which that wasn’t true, then there would be no point in using it, because it would be exactly the same as another program. Anyway, this isn’t a problem for most vim users, because most vim users are using vim for the majority of the time that they’re using their computer, so it’s not a big deal. Also, plenty of non-vim tools support subsets of vim’s keybindings, and plenty of non-vim editors (including most IDEs) have vim-emulation modes. And again, you can always rebind any key that you don’t like. Also, as I’ve said before, it’s designed to be accessible by muscle-memory. If you’re typing an email or whatever, you don’t have to memorize where all the letters are on the keyboard to use them, you just instinctively know where they all are because you’ve used them so much. I couldn’t tell you where the ‘c’ key is without looking down, but I can sure as hell type it when I need to. Vim is the same way.

    “The fact that it cannot send me to the definition of a symbol, nor can I see easily all the occurences of a certain word in a single file.”
    Vim has symbol support. See the following:
    http://vim.wikia.com/wiki/Browsing_programs_with_tags
    Also, if you hit ‘*’ while you’re on top of a word, it’ll bring you to the next occurrence of that word, and highlight all occurrences of that word in the file. Which makes them really easy to see. You can also highlight all occurrences of a word by searching for it, using ‘/’ and typing the word.

    “The stress induced on my memory for keeping all the features vim can have in mind.”
    ‘all the features vim can have’. Just assume that vim can have any feature you want it to have, that’s what I do. There’s a command or plugin for just about anything. It’s not like you have to know about, care about, or worry about any of the features that you don’t use, anyway. I also don’t really see how that’s different from using an IDE with a lot of features.

    “But, as I said, all these things I listed above are already said, and I’m tired of saying them.”
    This is actually the first time you’ve mentioned any of these things. Also, I apologize if I’ve been aggressive, that certainly wasn’t my intention. But you also have been extremely rude, perhaps also without meaning to be, so I suppose it’s fair. But I have been trying to be helpful, and I believe that I have succeeded so far (I did suggest nano, and you seem to be happy about that at least, which I’m glad for).

  24. Ok, let me spell it out loud. Too much information. Too much information needed to do basic stuff in an editor. Explain me the logic of “autocmd BufRead,BufNewFile * startinsert”. In fact, no, I get it, but why should I try to write a configuration file that makes vim feel like a normal editor just because vim cannot come out of the box like a decent editor?

    I don’t need you to help me understand, nor like my choice, nor argue with me about vim. I really don’t need, and that’s what you don’t get. My purpose is not to make vim better or to become a better vim user. My purpose is to show that in this day and age there’s no reason to start and finish with using vim. To almost everyone is pretty clear that they shouldn’t, except for vim fans that insist that vim is God-sent and they have to use it.

    I will have to explain you once again: when you have 60k options it’s equally difficult as when you have no options.

    edlin was a wonderful similarly limited editor, yet I see nobody praising edlin. Try edlin!

    And btw: what did you want to achieve with trying to convince me that vim is any good? Other than the fact that vim users only know how to suffocate people that dislike vim?

  25. Crap, some of my mappings didn’t show up properly … I guess wordpress eats things in angle brackets. I guess I’ll have to do it like this (the parentheses are angle brackets):

    cut/copy/paste remaps:
    noremap (c-x) d
    noremap (c-c) y
    noremap (c-v) p

    search highlight remap:
    noremap (tab) :nohl(cr)

  26. Pingback: Things I hate about vim « Technical corner

  27. Helo!!

    I try to installed and used Vim and worked for me!! Sadly background its too black which I do not like. How to change, do you know? Otherwise liked very much.

  28. “Why should I try to write a configuration file that makes vim feel like a normal editor just because vim cannot come out of the box like a decent editor?”
    I think this is where we disagree. A lot of people, myself included, struggle with ‘normal’ editors for a long time and wonder why there isn’t anything better. These people think ‘normal’ editors are clunky, hard to use, and not decent in the slightest. These are the people vim is made for, and these are the people who become vim users. If you’re writing a configuration file to make vim act like one of those other editors, you clearly aren’t the kind of person vim is for, and you clearly shouldn’t be using vim. You should be using one of the other editors.

    “what did you want to achieve with trying to convince me that vim is any good?”
    I wanted to get you to recognize that just because vim isn’t the right editor for you, that doesn’t mean it’s a bad choice for other people. And you say that you understand that, and you clearly don’t, because you continue to follow it up with ‘vim is a piece of crap’, ‘vim is a joke’, ‘vim isn’t any good’, ‘there’s absolutely no reason for anyone to ever use vim’, etc.

    You’re asking me why I’m spending my time trying to explain to you that vim can be a powerful tool for those willing to understand it? Then I get to ask you why you’re spending your time trying to tell me that it’s a piece of crap that’s about as useful as notepad or edlin. You feel ‘lynched’ by me because I have a problem with your unreasonable criticism? How do you think I feel when you unreasonably criticize something that I love to use every day? How is your behavior any different than those assholes who run around going ‘Windows is a stupid worthless piece of shit, nobody should use Windows, you’re an idiot for using Windows, Micro$oft steals your money, Bill Gates is Satan, lololol.’ I mean, I don’t like Windows much, but I do recognize that there are plenty of valid reasons for using it, and I also recognize that it’s a lot of people’s choice, and I respect them for making that choice because it’s their choice to make.

    I would never go up to someone and say, ‘you use Windows? Windows is terrible.’ But if I ever did, and if it was a reasonable person, I know they would say something like, ‘Well Windows works pretty well for me, and I like it. what exactly do you think is wrong with it?’ If, at that point, I felt as if they were lynching me, and I spent a lot of time yelling about how horrible windows users are for actually defending their choice of operating system, then wouldn’t that make me the irrational one? So how are your actions any different in this situation?

    “Explain me the logic of “autocmd BufRead,BufNewFile * startinsert”.”
    This is one thing I agree with. I mean, the logic is clear, but it could be much more clear. As I’ve said before, this is one of the biggest issues I have with vim: vimscript is a terrible programming language. I wish they used something better. I hope Neovim uses something better …

  29. @Jagjit Chanda

    “Sadly background its too black which I do not like. How to change, do you know?”
    You’ll need to change the colorscheme. There are some that come packaged with vim, but if you don’t like any of those, there are plenty of others you can download.
    http://vim.wikia.com/wiki/Switch_color_schemes

  30. Thank you!! Vim is best text editor I try. Very simple its perfect for to write blog post, no distraction.

  31. I freed myself of the shackles of emacs last week, and I’ve seen a boost in programming productivity. The turning point for me was after I had wasted almost two days trying to get a code browser to work again on an upgraded version of my OS. Only to find out that after I had gotten it to work, it still didn’t work quite the way I wanted (the common sense way in my opinion) and it looked like crap. That was the straw that broke the camel’s back and I simply went back to an editor that I’d used occasionally before. Geany. And guess what I discovered? It does everything that I was asking of emacs and more. The only features that are lacking, but not really missed that much, is adding custom snippets (which is possible in geany but less intuitive), and using the menus for snippet selection. On the other hand the things that do work, work better than in emacs and I have to spend ZERO time configuring the hell out of it and trying to make all the dependencies work only to have everything broken by the next update of another link in the endless chain of dependencies. Or dealing with conflicting packages, etc. Geany just WORKS. Only by leaving emacs I discovered how much of a productivity drag it was, either by not having things work right or by making you waste hours of your time trying to make them work right. I feel truly liberated. Up until that point I had told myself that the learning curve may be steep, but it’s all worth it in the end. I don’t believe that any more after more than a year of intense usage. I mean, think about what you really gain and how much time you waste on getting there. I’d seen the videos about artist mode and HTML tables etc. I never considered these of any use to me. I used org mode for a while, but soon discovered that emacs was utterly the wrong tool for this kind of task. My sense is emacs is for enthusiasts who want to use nothing else. I love linux. Emacs is an editor. I don’t love emacs. But for Stallman, the GNU OS guy, and emacs enthusiasts they use it almost like an operating system, where they never have to leave it. That’s fine for them, but that won’t work for me. For me linux is the winner and that’s where I work with the appropriate tools for different jobs. Emacs is an appropriate tool for remote shell editing. That’s it as far as I’m concerned. Open it, do a quick edit, say bye bye. I have less experience with vim, but my atttitude is pretty much the same. Initially I considered giving vim a try, but dismissed that quickly. I can use vim for quick tasks, that’s enough. I’ll never use it as an IDE like editor. There’s just no need to go through that pain. Never again.

  32. @Liberty

    I used to use geany, it’s pretty excellent. I used it for years, but after a while I got to the point where I just felt like I wasn’t being productive enough. That’s why I switched to vim, and I have to say it was one of the best decisions I’ve ever made. My productivity skyrocketed. Recently, I gave emacs a try … I couldn’t do it. You’re right, there’s way too much configuration to make it work how you want. That’s the emacs thing: it’s not an editor, it’s a lisp platform that has an editor plugin. If you have enough time and patience, you can make emacs do anything you want. Which is great, I totally respect it, but it’s not for me.

    See, the reason emacs requires so much maintenance is because that’s what emacs is about: configuration, extension, basically customization. That’s emacs’ thing. Vim is a little different. It supports the configuration and the customization, and that comes in handy, but it isn’t the focus of the project, it isn’t vim’s thing. Vim’s thing, actually, is productivity. You don’t get vim, customize the hell out of it to make it do things the way you want, and then use it. You get vim, learn how it does things, and change the way you do things to match because it’s so much more productive that way. Then, if one day you realize that you’re missing a feature or if there’s something getting in the way of your productivity, you add an extension or a line to your config, and you’re done.

    Basically what I’m saying is, emacs is for people who don’t feel comfortable unless their editor works exactly the way they expect it, to the point where they don’t mind the huge config timesink (even then, I couldn’t get things to work exactly right in emacs when I tried). Vim, on the other hand, is for people who want to be extremely productive. The major timesink in vim is not configuration, but just learning how to use it. Once you get proficient at it, though, you get that time back, and then you save a lot more. Of course, if you’re not willing to do that either, then by all means, geany is a wonderful alternative.

  33. Tucker. you know what’s also a great boon? Tabs. Yep, such a simple tool but so indispensable in organizing your windows for greater productivity. Not just the document windows, but the shell, code browsing windows, directory views and so on. Emacs doesn’t have tabs and as far as I know vim doesn’t have them either. I can imagine emacs trying to integrate some form of tabs into their editor and what that would look like. Probably not something I would want to use. And like I said I don’t see a reason to switch away from geany for the time being. You didn’t mention what productivity problems you had with geany, but for my workflow I don’t see those on the horizon yet. Another thing about emacs that I kinda found annoying all the time but sort of just put up with is the scrolling. Simply moving the cursor to the bottom or top of the window suddenly makes the whole screen jump. You can’t choose exactly the section of the code that you want to view. You have to be liberated to realize the real weight of the shackles you were wearing. At least vim doesn’t have that sort of behavior. But anyway, I appreciate your enthusiasm for vim, but like I said, I won’t use it for programming. I feel blessed just thinking about code and problem solving and not worrying about the editor at all. And that includes not having to consider vim. I understand that you say vim has no configuration problems and all but I reserve my skepticism. The thing is this. If I open a python file in vim I don’t get something that I can work with for programming by a long shot. So I will have to configure it and I’m not going down that path again.

  34. Fool me once, shame on you. Fool me twice … you know … a fool man can’t get fooled again.

  35. @Liberty

    I assumed emacs had tabs, but maybe not … I know vim does though, I use tabs all the time in my vim. They’re amazingly helpful for organizing my windows and views and things. Granted, tabs in vim are a little different than tabs in geany and other editors. In geany, each tab is just a viewport for one buffer, but in vim you can split a tab up into subwindows and open different buffers in it and things like that. I never liked using tabs in geany, because if there are too many of them, they don’t fit on the screen, and I can’t see all my files. I always used the document list sidebar to switch between documents, it’s much nicer I think. Anyway, in vim, there’s actually an even better way to do this. It’s a plugin called ctrlp, and it’s basically just Sublime’s Goto Anything. You hit ctrl+p, and it pops up a footer with all the files you have open, and you can arrow to one and open it, or you can type part of the filename and it’ll narrow the list for you. You can use it to open files from the disk too, and to jump to particular symbols as well. No need to scroll around looking for the file you want. Much more productive than geany’s tabs,

    My productivity problems with geany are the same as my productivity problems with every other editor that isn’t vim: all editing is slow and clunky. Of course, I didn’t realize that I was having these problems at first, since I hadn’t known anything different, but once I watched a few people use vim and once I learned a bit more about what it can do, I started to notice all the little unproductive things I was being forced to do all the time, and I started to get annoyed by them. I’ll try to give some examples of what I mean. Say you want to find a particular occurrence of a word in your document. In geany, you have to stretch your little finger to ctrl, hit f, and redirect your attention to this new popup window. Then you have to make sure the window isn’t in the way of your viewport, and if it is, you have to reach all the way over to the mouse, drag it to the top of the window, click, move it over to somewhere out of the way, let go, and move your hand back to the keyboard. Then you have to type what you’re looking for and hit enter. Then you have to hit enter a few more times until you find the right one. Then you have to reach for the mouse again to close out of the find box, so you can go back to editing your file. Now, let’s say you want to do the same thing in vim. Just hit /, type your word, and hit enter. Hit n until you get to the one you want. And you’re already ready to do more editing. Much faster, no need to reach over to the mouse or the ctrl key, no need to worry about switching focus to a subwindow or worrying about positioning things correctly. Much more productive.

    Productivity isn’t just about how fast you perform an action, it’s mostly about how many steps your brain has to go through and how much extra stuff it has to think about while you’re doing the action. People don’t realize how many things your brain has to process when operating a mouse. You have to locate the mouse pointer, locate where you want to go, move the pointer toward that point. If you’re not quite there, or if you overshot, do it again. Usually you repeat this two to four times, and this is just moving the mouse. Not to mention how much extra time it takes to move your hand back and forth between the mouse and the keyboard. Let me give another example. Let’s say you’re writing in a string literal, with double quotes around it. Let’s say you decide that you want to start over, delete the contents of the string literal and start fresh. In geany, you reach over to the mouse, position it at the start of the string, make sure it’s right in the middle between the quote and the first character. Then you click and drag all the way to the end of the string. If you fucked up, click out of the selection, and try again. Once you have the string selected, put your hand back on the keyboard and hit delete. Now you can start typing. Compare that to vim. You think, “I want to Change the text Inside these double quotes”. You type ci” and you start typing your new string. ci” means “Change Inside Double Quotes”. This can also be done with single quotes, words, sentences, paragraphs, lines, parentheses, brackets, braces, and more. This is called a text object, and it’s one of the coolest features in vim. It also requires three keystrokes and zero mucking about with the mouse. Much more productive. As I said before, productivity is about how many steps your brain has to go through to perform an action. The idea behind text objects is, it lets you edit in terms of the ‘objects’ that your brain thinks about when it thinks about text. The alternative, of course, is that what geany does: you have to edit in terms of characters, and that forces your brain to worry about which characters represent the bits of text it wants to edit. Text objects also eliminate many accidental edits: In geany, if you select one character too many, you have to do the selection again. In vim, ci” will do exactly the same thing, no matter where your cursor is in the string. You can’t mess up the selection. This, I think, is far more productive.

    Yeah, the scrolling in emacs sucks, I don’t know if there’s a way to change it but I haven’t found one. That’s honestly one of the reasons I couldn’t use emacs when I tried. Vim doesn’t have that problem, if you scroll off the page it just scrolls one line, like in geany. In vim you can also use the z commands to do some nice autoscrolling: zt will scroll the page so your cursor is on the top line, zz will scroll so your cursor is on the middle line, and zb is the same for the bottom line. I use this all the time.

    I didn’t say vim has no configuration problems, I just said it isn’t an absolute bitch about it like emacs is. The amount of time I spent configuring vim the day I started using it is about the same amount of time I spend configuring geany when I started using that. Vim is fully configurable, and there are a number of default options that aren’t optimal (a handful of bad keybindings, opening and switching between files is really sucky if you don’t have ctrlp or something like it installed, things like that). But these things are really easy to change, usually just one line in your .vimrc will fix any given thing. And most customizations happen over time. I’ve been messing with my config ever since I started using vim, but it’s not a big timesink at all because I spend maybe a minute or two per month realizing I need to change something, figuring out how to do it, and doing it, and then I’m done until I find something else in another month or two. And the default configuration is perfectly fine for editing individual files and things. Why, what kind of problems do you run into when opening a python file that makes it unworkable? That surprises me.

    I’m not trying to get you to switch or anything like that. I’m just expressing where I’m coming from.

    • “Yeah, the scrolling in emacs sucks, I don’t know if there’s a way to change it ”

      Of course there is, it’s GNU Emacs 😛

      I’m going to write something terrifying here … if you want to know about scrolling in GNU Emacs, then read the manual.

      The information about scrolling is in the “Controlling the display” entry under “Scrolling” and “Auto-scrolling”.

      I assume that the effect you want is for the text to scroll by one line each time you move the point off the top or bottom of the screen, but to leave the point in the same place physically on the screen at the top and the bottom (no centring or the like).

      Sticking this into your .emacs will do that (as per the manual):

      (setq scroll-conservatively 101)

      There are other ways to produce similar or nuanced ways of achieving the kind of scrolling you like.

      Personally, I like the mostly default behaviour. I like to see my code properly in context, so the standard behaviour of moving half a screen and centring the point vertically is exactly what I want. The only change is to set scroll-margin to 3 so that auto-scrolling gets triggered 3 lines from the top or bottom of the screen.

      I also bind scroll-up-one-line and scroll-down-one line to convenient keys (it’s up to you), so that I can move up and down a buffer by a few lines whilst leaving the point in the same place relative to the document.

      There’s masses of other stuff to do with scrolling and centring etc etc. Just read the manual. 🙂

      PS. Oh, yes, tabs. There are a number of ways of doing tabs. I’ve never been interested in in tabs, just as I’m not interested in the menu bar, the button bar or scroll bars.

    • @ecadre
      Huh, that’s cool about the scrolling. No matter how much I looked or googled before I couldn’t find any easy way to do that, even though now when I google it’s right there, so I don’t know what’s up with that. Anyway, thanks. I might give emacs another shot at some point, I dunno. I kind of can’t function without vim bindings so last time I installed evil-mode, but it’s not perfect. But that doesn’t really matter as long as the differences aren’t too bad or confusing.

      “Personally, I like the mostly default behaviour. I like to see my code properly in context, so the standard behaviour of moving half a screen and centring the point vertically is exactly what I want.”
      I like that too, which is why I don’t like the default behavior: the section of code that it decides to show me almost never actually corresponds to the context I want to see, it’ll cut off the top by a quarter page or the bottom by a quarter page and there’s no middle ground, and that’s really annoying. In vim I can scroll to where I want and hit ‘zz’ to center the point on the screen, that way I get the entire context. I’m sure you can do that in emacs too, though. I just don’t like my text jumping around large amounts, I lose track of the code I’m looking at too easily and it’s a chore finding my place again.

      “I also bind scroll-up-one-line and scroll-down-one line to convenient keys (it’s up to you), so that I can move up and down a buffer by a few lines whilst leaving the point in the same place relative to the document.”
      I do that sometimes in vim, it’s ctrl-e and ctrl-y by default. It’s pretty useful in some situations.

  36. Vim is crazily powerful, cross-platform and free… yet everything it does it does so terribly assbackwards. I do use it often due to its strengths, but I hate every minute spent with it. And if you happen to enjoy this, face it – you are crippled the Vim way. Do not assume it is OK, or suggest others to use. It should die out so that another, both powerful and human-friendly editor may appear.

  37. @Slava

    “everything it does it does so terribly assbackwards”.

    Like what, for instance? Could you expand on this? I’ve always thought the concepts vim introduces are leaps and bound ahead of any other editor … if they were assbackwards, they wouldn’t be powerful, would they?

    I do agree that vim has a small handful of rather awkward default settings, but nothing you can’t fix easily with a line in your config. Also vimscript is kind of a shit programming language, but it’s a perfectly acceptable config language, and it’s not your only choice for writing plugins (vim comes with bindings for python, perl, ruby, lua, and maybe some others). Also, I guess vim isn’t the best at some things, emacs and other editors can do some things better. Emacs is more extensible because the concepts it uses are more general, but then emacs is meant to be a full lisp platform and not just a text editor. Emacs is slightly better at correct autoindentation and syntax hilighting in some languages sometimes, but that’s more of a minor support issue (and when it comes down to it, vim’s syntax hilighting is better in general because it supports more hilight groups, which increases code readability). But, all of those are just minor issues, most of them are fixable, and none of them are ‘terribly assbackwards’, just a tad lacking. Which is fine, it’s not like any editor is perfect.

    Anyway, all of that is easily forgivable when you take all the brilliant parts of vim into account: modal editing, text objects, key composition, etc etc. The fact that it’s highly customizable and supports or has plugins for pretty much anything you could want in a text editor is icing on the cake.

  38. Hmm, I’m vim user but not an expert one, just a basic user (know only how to navigate and only handful of commands)

    Like you said, when busy days, programmer could write several tens or hundreds line of codes. But to me, when I write I always keen on repeated code, so at first when coding, I usually recognize the pattern and I edit my design to make more general. So it’s the code design that’s crippled instead of bashing the text editor/IDE.

    You can make your code more generic and short with smart usage of functions composition and higher-order functions. That’s why when someone write 100-200 lines of codes, I edit my codes from 200 lines to 100 lines. That’s why vim is really my favorite as I tend to edit more.

    Oh, if you are OOP programmer, my bad, you have my condolence then. Surely IDE is definitely your thing because you need to write those boilerplate codes and type those repeated word again and again.

  39. I agree with your points and have experienced personally the ridicule that serious VIM users inflict on those of us that don’t use it. 20 years in the industry and I have worked with no one that uses VIM to write code. I have friends that use it but never worked with them. I’ve also used it myself for a year or so when I was in a “phase”.

    The number one argument that I get from VIM users is the “we don’t like to have to use the mouse” argument. I used both Visual Studio and Eclipse quite successfully without mousing. They both have a great set of keyboard shortcuts, can be modified and even extended with macros and plugins.

    So, anyway, I just don’t like the VIM input paradigm and the cryptic commands. I won’t teach new programmers to use it and I still let all my developers use any editor they like. Most just use VS, others use a combo of VS and some other things. BTW, Has anyone pointed out that most of those paradigms in VIM date back to computers that didn’t have monitors but just printed output?

    • Great answer: the point is that no, nobody actually pointed that out. However, I do understand the “keyboard only” paradigm, and the way vim does it is relatively ok, although I myself prefer a more direct-input mode to be dominant (the way it is in Emacs, or all the other editors on this planet).

      I think that elitism in use of a tool is silly, ‘s all.

    • Great answer: the point is that no, nobody actually pointed that out. However, I do understand the “keyboard only” paradigm, and the way vim does it is relatively ok, although I myself prefer a more direct-input mode to be dominant (the way it is in Emacs, or all the other editors on this planet).

      I think that elitism in use of a tool is silly, ‘s all.

    • ‘The number one argument that I get from VIM users is the “we don’t like to have to use the mouse” argument.’

      That’s silly, since that’s just as valid an argument for Emacs, VIM’s primary flamewar opposition. The main argument I hear for using VIM, generally, is “I’d rather not use the mouse, but also the keyboard shortcuts non-vim editors have are horrible in comparison.” I can’t stand all the complex ctrl+shift+random bullshit you get with other editors. With VIM, your keyboard shortcuts are all simple to use and easy to remember (fewer modifiers and complex keystrokes, all the shortcut keys are the first letter of the thing they do, etc), and it’s all set up really nicely.

      No, I wouldn’t recommend it to beginners at all, VIM is for power users obviously, and of course you should let people use whatever editor they’re most comfortable with. But that doesn’t mean VIM isn’t as good or valid an option as any other, and it definitely doesn’t mean it’s outdated in any way. I know you guys like your IDEs, but I personally can’t stand them, and I’ll tell you why:

      IDEs are too bloated for my taste. They take way too long to start, and they have huge menus and docs that are full of things I’ll never ever use. It’s just a big waste of resources, and a waste of time at the beginning of the day. I shouldn’t have to wait more than a second or two for something as simple as a text editor to start up, and I certainly shouldn’t have to wait thirty seconds to a minute, but that’s how long Eclipse and most other IDEs take.
      IDEs are way too complex to configure. All those menus and wizards and everything make my brain hurt, and they all save to either big clunky xml files or special unreadable domain-specific files or god knows what else, and there are a ton of these stored all over the place, I can’t keep track of them all. Not to mention most IDEs have their own special project files that they need to save in your project’s directory which is extremely annoying all the time. Isn’t there a simpler way? Why yes there is. VIM gets it. Emacs gets it. Hell, even Sublime gets it. All you need is one text file with one simple syntax where you put all your configuration. Much better.
      IDEs are much too cluttered. There are always sidebars or hover windows or whatever open all over the place. When I’m editing code I want to see my code, and anything else on the screen is just distracting. This isn’t as big of a deal because you can configure this away in most IDEs, but it takes a while to disable all of those little distractions, so it’s still annoying.
      IDEs tend to have their own style and workflow, and resist conforming to that of the user. Even before I started using VIM, I couldn’t find an IDE that I was comfortable with, simply because none of them would let me use a workflow I was comfortable with. For example, I can’t stand Eclipse’s ‘workspace’ system, it causes me no end of annoyance. This is also tangentially related to what I said earlier about IDEs leaving useless project files everywhere.

      So yeah, IDEs aren’t my thing, and VIM is. That doesn’t mean I’m going to try to push it on you or anyone else, especially not beginners. That said, I do take issue with what the author of the article here is doing: attempting to disguise a cheap shot at a decent tool as a set of legitimate concerns, attempting to disguise a cheap shot at the tool’s mostly decent userbase as a set of legitimate concerns, mistakenly believing that the reason he had a bad time with VIM is because VIM is a bad tool, mistakenly believing that the reason he had a bad time with VIM is because all of VIM’s users are bigoted, elitist assholes, etc. It would be one thing if this article was actually about what its title seems to think it’s about: an attempt to explain why teaching VIM to new programmers is probably a bad idea, and an honest attempt to show people that forcing your tool of choice (any tool, not just VIM) on others is generally going to be a bad idea because every choice is legitimate for its own purposes and everybody has their own preferences. All of that would be great to see in an article, but that’s not what this is. This article is nothing more than a description of how ‘bad’ VIM is for anyone to use, how ‘outdated’ it is, and how all of its users are horrible bigoted assholes. In short, the author of this article is being just as much of an elitist (about IDEs) as the VIM users he discusses, and that’s not alright, I think.

  40. @Tucker: the whole point is that it’s not about convincing already entrenched users to give up VIM. It’s about what beginners should be told. And honestly, VIM people are terrible when it comes to giving a fair comparison between VIM and a good IDE. Example: you wrote above that VIM supports symbols, that is jumping to a symbol, etc. The goal of your statement is clearly to show that VIM has equivalents to these important IDE features.

    The problem is that it doesn’t. Ctags, gtags, etc are bad on reasonably complex c++, it’s much worse compared to Eclipse’s indexer. YouCompleteMe is probably the most accurate package you can get for that sort of thing for VIM. Though it works reasonably well, it’s harder to setup, not as performant for incremental changes (these first two are both a result of using clang as the backend), and nowhere near as featureful. In Eclipse I can search my entire project with incremental matching and splatting, not only for files (which VIM users often cite as a killer feature in some VIM plugin, not being aware that every single IDE has this), but also for classes, functions, macros enumerations, typedefs, etc. How about finding all the references to a given variable, function, etc? Can’t do that either. In Eclipse I can do that, as well as look at type, call, and include graphs/hierarchies.

    The thing is that reading code takes up much more time than writing code. So I’d prefer sophisticated features for reading code, over sophisticated features for writing code. And if you want a final nail in the coffin: just about every major IDE nowadays has at least decent VIM emulation. I recently used Eclipse + Vrapper to fix a bunch of compiler warnings; I was using the IDE features to find problem areas, and using VIM macros to fix them.

    What’s really not ok is the way that so much of the VIM community is getting young developers to jump into VIM without giving IDEs an honest shot. I’ve lost track of how many times I’ve heard a VIM/emacs person say that using these tools will actually make you a better programmer (false, and actually awful if anyone thinks that). Or that VIM/emacs makes you more productive because you have keyboard shortcuts for everything (because clearly IDE users use the mouse to click on everything). Or that VIM/emacs have plugins for every aspect of IDE functionality (completely false). Or that with VIM/emacs you can use all these awesome command line tools like grep and sed; as though launching eclipse disables my console and I don’t use grep on a regular basis. Or getting people to focus on things that are (or should be) irrelevant: I don’t care that Eclipse uses 2 gigs of RAM when I have 16, and I don’t care how long it takes to start when it runs all day. The author’s basic point is that needing to work through a terminal is the only good reason to use VIM/emacs, and he’s 100% correct.

    The fundamental problem, and difference between IDE and vim/emacs people, is that the latter (in many cases) have let their tool become part of their identity. That’s why they care so much and advocate so deeply. That’s why they attack with so much vitriol when an article like this is written. Do you think anyone cares to the same extent when someone writes an article ripping Eclipse? I would kick Eclipse to the curb tomorrow if something with better features came along. I’m not an “Eclipse person”, I’m a C++ programmer who wants the best tools for the job, whatever they happen to be.

    • “The goal of your statement is clearly to show that VIM has equivalents to these important IDE features.”
      I guess? I don’t think those features are that important, I never use them anyway. I don’t know what the ctag support is like in Vim, I’ve just heard that it exists, but I’ve never had a reason to use it. You know how I find things like function/variable/class/type/macro defs/uses (and literally anything else) in my projects? I use ack. That’s a wonderful tool for the job. Actually, I’ve recently found a pretty nice plugin for vim called ctrlsf (https://github.com/dyng/ctrlsf.vim), it makes searching and refactoring from within Vim extremely fast and easy, and it uses ack to do it, or ag, which is supposed to be the same thing as ack except noticeably faster.

      “The thing is that reading code takes up much more time than writing code.”
      I suppose so? When you’re reading code you’re limited to how fast you can read, but no editing tool is going to change that. The only thing I can think of that would make reading code faster is proper documentation. I do understand where you’re coming from though, when you have multiple levels of indirection spread out over many files you have to be able to quickly follow the chain of reasoning between those files, but again, I can do that just as fast with ctrlsf as I can in an IDE. The thing is that editing code takes up much more time than reading or writing code, and that’s where Vim excels.

      “just about every major IDE nowadays has at least decent VIM emulation.”
      I guess? I’ve been forced to use Intellij IDEA in my workplace recently, and I enjoy a lot of things about it, one of which is that it’s actually usable without me having to bash my head against a wall until it bleeds (as opposed to Visual Studio and Eclipse which are severely painful to try to do anything with at all), and another of which is that when I first started it up, it asked me if I wanted to install the vim plugin. And it’s fine. It’s not great, but it’s okay. Most things work the way I expect them to, some don’t, but more importantly, I don’t get any of the cool plugins I have in Vim. I have access to some of the same functionality, but it’s not all there. It’s the same problem I had when trying to switch to emacs/evil-mode. Vim emulation =/= Vim.

      “I don’t care how long it takes to start when it runs all day.”
      Even if it’s only once, waiting for that shit to start up still annoys the hell out of me. And it’s not just once either, because IDEs require a restart every time you install a plugin or change some major configuration. I’m pretty sure you don’t even need to do that in Vim, but even if you do it’s not really a problem because it starts instantly. But, even emacs takes too long to start, for me. I dunno, it just annoys me on a conceptual level: something as simple as a text editor should not have to take multiple seconds to start up.

      “Or that VIM/emacs makes you more productive because you have keyboard shortcuts for everything.”
      Well, not so much emacs, and not so much ‘more productive’, but with Vim you waste less time doing tedious things because of the keyboard shortcuts. This primarily has to do with the fact that Vim’s shortcuts can do more in fewer keystrokes, don’t require the use of modifier keys nearly as often (I’m not a fan of straining my little finger every time I want to do anything at all), and are more powerful and versatile because of things like key composition and text objects. I would say that emacs can technically also make you more productive, but that’s only because you can conform it to your personal use and workflow to an infinite degree, which can increase your productivity because you don’t have to fight your editor to get things done (you can do this with Vim too, just not to the same extent).

      “Or that VIM/emacs have plugins for every aspect of IDE functionality”
      I guess not, but the point is that they can. If a plugin doesn’t exist, you can just make it yourself, especially in emacs. And as far as I’m concerned, Vim has plugins for every aspect of IDE functionality that I actually use, and also it has plugins for every aspect of functionality that I need that IDEs don’t support.

      “I’ve lost track of how many times I’ve heard a VIM/emacs person say that using these tools will actually make you a better programmer”
      I completely agree with you on this one, that’s just stupid. Vim can make you better at writing code, but it doesn’t magically increase the quality of that code. No editor or tool can do that.

      “What’s really not ok is the way that so much of the VIM community is getting young developers to jump into VIM without giving IDEs an honest shot.”
      Really? Because every Vim user I’ve ever met uses Vim because they used to use IDEs and hated it. I’ve never heard of anyone starting on Vim, that’s absolutely ludicrous.

      “The author’s basic point is that needing to work through a terminal is the only good reason to use VIM/emacs, and he’s 100% correct.”
      That is one of the points the author made, yes. And this is at the heart of what bugs me about this article: The author’s basic point is supposed to be that teaching Vim to new programmers is a bad idea. That’s what he says the article is about. But it turns out that the article is actually about how he’s scared of terminals and how all Vim users are terrible people and shit like that. “needing to work through a terminal is the only good reason to use Vim”. Because I suppose you should only work through a terminal when you ‘need’ to? If you’re talking about Windows then I get where you’re coming from, the DOS terminal is a piece of shit, but I use Linux at work and home and I prefer to use the terminal, it’s so much easier to get things done in terminals. So in that case I’d rather use a terminal-based editor. But again, that’s just my personal preference.

      “Do you think anyone cares to the same extent when someone writes an article ripping Eclipse?”
      No, because Eclipse is terrible. Eclipse is the worst IDE I’ve ever used, and I can actually say that now because I’ve used IDEA (which I actually kinda sorta like) so I have another mainstream IDE to compare it to. People don’t freak out about Vim because it’s ‘part of their identity’, people freak out about it because it’s really good. People talk about Vim like it’s the greatest thing in the world because when they use it, it makes them feel like it’s the greatest thing in the world. Vim is the only editor I’ve ever used that’s had that effect on me. Hell, even watching people use Vim has that effect on me, that’s what got me into Vim in the first place. A couple years ago, one of my professors was editing some code on the projector, and he did it so fast it was like magic, and I was like “I want to learn to do that shit”. You don’t get that with IDEs.

      “I would kick Eclipse to the curb tomorrow if something with better features came along.”
      You think I wouldn’t? You think that if something that combined the best parts of Vim and Emacs appeared on Github tomorrow I wouldn’t drop Vim for that in a heartbeat? I totally would. The thing, though, is that this is extremely unlikely to actually happen. Although it might happen, NeoVim might be the greatest thing ever, it’s still in beta and it can already do things Vim can’t do, like run a terminal emulator in a buffer (which is probably the most useful thing that Vim can’t actually do, which is honestly horrible). But yeah, don’t imply that Vim users will forever just stick to Vim no matter what else comes out. If Vim users were actually like that, they’d still be using Vi. Or ed.

      “I’m a C++ programmer who wants the best tools for the job, whatever they happen to be.”
      That’s all well and good, and an IDE might just be the best tool for a C++ programmer. But I’m not an (insert language here) programmer, I’m a programmer. Day to day I use a wide variety of languages, from the general-purpose to the domain-specific, from the mainstream to the less-well-known to the in-house. The thing that makes IDEs work so well for particular languages is that they’re programmed specifically to support that language really well, which is fine, but it comes with the caveat that those particular IDEs can’t be very easily used with other languages. Many of the languages I use every day aren’t well-supported by any of the mainstream IDEs. Vim, on the other hand, is specifically designed to work well for programming in general, with any language at all. I personally think this is the true power of something like Vim or emacs or even Sublime, over IDEs. That does mean the support is not quite as good for any language in particular, but in my case that’s not a problem. In your case it might be I suppose, since you’re ‘a C++ programmer’. I would, then, like to suggest you give CLion a try. It’s an IDE by JetBrains (the people who made IDEA and PyCharm which are the only two IDEs I actually like) designed specifically for C and C++ (unlike Eclipse, which is primarily for Java and only supports C++ as an afterthought via a plugin). Anyway, just a suggestion.

    • @Tucker: “…makes searching and refactoring from within Vim extremely fast and easy, and it uses ack to do it, or ag, which is supposed to be the same thing as ack except noticeably faster”

      First of all, this is obviously exaggerated, any suggestion that “searching and refactoring” in Vim would be faster than in IDEs. Such declaration from vim fans only mess up things, because the point is not speed of things (I can do things faster if I write a shell script that does renames, for example) but: how long does it take to discover that feature, how easy it is to perform that operation, how much stuff do I have to get acquainted to before doing that. The answers for vim are: “too long, too much, too many”.

      But most importantly, the fact that an IDE starts with all the things bound and ready to use, that’s what makes me use an IDE instead of Vim or even Notepad++. I don’t have to load suspicious add-in to do magic stuff for me. I already have my IDE more or less complete.

      Really, you have to work on 1+MLOC projects to really understand what an IDE is good for.

    • Okay, so you’re basically saying that an IDE is the best tool for anyone working predominantly in a few languages that are well supported by IDEs? If so, then we totally agree. The guys working in 12 languages, including Algol and SmallTalk, sure, vim is probably better for those guys.

      Most people work mostly in a few languages, because it makes a lot of sense to do so. And most popular languages have good IDE support. So really, you should fully agree with this article. 99% of developers will work in conditions similar to what I described, and therefore should learn an IDE.

      Also, FYI, Clion is nowhere near where Eclipse as a C++ IDE, yet. The JetBrains guys are very good, and Clion will probably surpass it, but not yet. The quality of the Clion indexer is just much poorer than Eclipse’s, they still haven’t resolved very basic bugs that I filed months ago. You sound like someone who used Eclipse 4 years ago, hated it, and haven’t looked back. I’ve tried every C++ IDE worth mentioning in the last year, and compared their ability to parse code head to head. I assure you, Eclipse is the best. Oh, and one of my main beefs with PyCharm compared to PyDev? Eclipse has much better vim emulation than PyCharm.

    • @Dorin
      “First of all, this is obviously exaggerated, any suggestion that “searching and refactoring” in Vim would be faster than in IDEs.”
      Wow, I knew you were terrible at listening but jeez. No, I never said searching in Vim was faster than searching in IDEs, if anything they’re about comparable speeds. I said ag was faster than ack, but I never said anything about IDEs …

      “the point is not speed of things, but: how long does it take to discover that feature, how easy it is to perform that operation, how much stuff do I have to get acquainted to before doing that.”
      Why? Once you discover the feature, and get acquainted with it, those things don’t matter. And ‘how easy is it to perform that operation’, as easy as you make it, considering you get to decide what the keybindings are. If things like ‘how easy is it to learn’ actually mattered to you, you wouldn’t be a programmer in the first place, you’d have been scared away by your first language.

      “But most importantly, the fact that an IDE starts with all the things bound and ready to use, that’s what makes me use an IDE instead of Vim or even Notepad++.”
      Except that it doesn’t? If you’re using Eclipse, and you need support for a language other than Java or a VCS other than Subversion or anything else you might want, you need to install a plugin for it. Also Vim plugins aren’t suspicious or magic, because they’re just text files written in vimscript or python or lua or something, you can read the source code as much as you want.

      “Really, you have to work on 1+MLOC projects to really understand what an IDE is good for.”
      I do. Every day. Still not sure what all the fuss is about.

    • Let me cut your quote, because you can’t really focus on such large texts: “makes searching and refactoring from within Vim extremely fast and easy”. Refactoring from within Vim cannot be extremely fast and easy, that’s what I picked on, and yeah, let’s leave it at that.

      I am not a fan of eclipse and the myriad of things needed to install. I like my IDE bare, with all things in it or not at all, but it’s a preference.

      With vim, on the other hand, I have to learn about a gazillion things that will allow me to do stuff in a very memory-exhausting way. I’m not referring to computer memory, I’m referring to my memory, which is the scarce resource here.

      So frankly, I couldn’t give a rat’s ass about what vim can do: it takes too much learning to do the things I already do with my IDE.

    • @quicknir
      “Okay, so you’re basically saying that an IDE is the best tool for anyone working predominantly in a few languages that are well supported by IDEs?”
      No. I’m saying that the best tool for anyone depends entirely on who that person is and what they’re trying to do. Personal preference, comfort level, learning ability, deadlines, etc play as big a part in deciding which tool is right for the job as the actual job does. It’s a case-by-case thing. All I meant by what I said is that in my particular case, IDEs are a bad choice because of the variety of languages I use. However, the best choice for someone else in the same situation might just be to learn twelve different IDEs or something. I’m just saying it’s not generalizable like that. I think that in most situations, you should try multiple different tools and choose the ones you think are best for your particular situation. This isn’t always the case either, but it’s a good rule of thumb I think.

      “Most people work mostly in a few languages, because it makes a lot of sense to do so.”
      Yeah, web development never made much sense to me either. I kid, though. No, I don’t think you’re correct about that, I think it makes the most sense to use different languages depending on what you’re trying to accomplish. If you have something that needs to run very fast, you should use C. If you need code that is extremely stable and bug-free, Haskell. If you need to write your code very quickly, Python. If you’re writing short snippets that use a lot of external tools and not much in terms of data types, Bash. If you’re writing really complex code where many levels of indirection is key, a Lisp might be a good choice. If you’re parsing and generating a lot of XML, I would suggest Groovy or something. Different languages have different strengths and weaknesses, and you always want to choose a language who’s strengths match the needs of your program. Just using Java for literally everything is a terrible idea.

      So really, you should fully agree with this article.”
      Wait … why? This article is about how horrible Vim users supposedly are and how outdated the terminal supposedly is and how bad Vim’s learning curve is. It has nothing to do with what you’re talking about.

      “Also, FYI, Clion is nowhere near where Eclipse as a C++ IDE, yet.”
      Alright. I dunno, I’ve never used CLion, I just know the JetBrains stuff I have used is pretty good comparatively.

      “You sound like someone who used Eclipse 4 years ago, hated it, and haven’t looked back.”
      I’ve actually used it infrequently for the last four years and have hated it every time. The last time I gave it a shot was a couple days ago. It hasn’t changed a bit as far as I can tell.

      “I’ve tried every C++ IDE worth mentioning in the last year, and compared their ability to parse code head to head.”
      Ability to parse code? What exactly are you actually looking at? What is ‘indexing quality’, are you just talking about speed? Or does CLion miss instances of things in your code?

      “Eclipse has much better vim emulation than PyCharm.”
      I’ve never used PyCharm’s Vim emulation, so I don’t know.

    • “Let me cut your quote, because you can’t really focus on such large texts: “makes searching and refactoring from within Vim extremely fast and easy”. Refactoring from within Vim cannot be extremely fast and easy, that’s what I picked on, and yeah, let’s leave it at that.”
      … yes it can. And I never compared it to IDEs in this quote, although, again, it’s just as fast and easy as it is in an IDE.

      “I am not a fan of eclipse and the myriad of things needed to install. I like my IDE bare, with all things in it or not at all, but it’s a preference.”
      And I like my Vim. It’s a preference. No need to write an article about how much of an asshole I am over it.

      “With vim, on the other hand, I have to learn about a gazillion things that will allow me to do stuff in a very memory-exhausting way. I’m not referring to computer memory, I’m referring to my memory, which is the scarce resource here.”
      Like what? The keybindings? So you think I went and memorized all the Vim keybindings? Fuck no, I don’t have a big list of key/function pairs memorized. With Vim it’s more of a mindset thing. You want to undo. What do you press? Well, what letter does ‘undo’ start with? Things like that. And if you do that enough, it just becomes muscle memory, second nature. And you don’t do them all at once, you learn like three of them and then you add one or two keys at a time whenever you find you need it. I guess you might also be talking about the commands though. I don’t fucking know what all the vimscript commands are either, I just google them as I need them. If there’s one I think I might use a lot, and I don’t think I can remember it, I just make a leader binding for it that I know I can remember more easily. Or maybe you’re talking about the plugins? I don’t fucking know what all the plugins are, nobody does. You just find them as you go. I’ve been using Vim for years, and I didn’t know about ctrlsf (which makes my life loads easier) until a month or two ago. You just take the plugins you think you need, and you forget the rest, no need to worry about all of them. You’re making this shit a lot more difficult than it actually is, is all I’m saying.

      “So frankly, I couldn’t give a rat’s ass about what vim can do: it takes too much learning to do the things I already do with my IDE.”
      Okay, that’s fine. A lot of people don’t have time for that kind of thing. A lot of my friends keep pestering me to switch to Dvorak, but I’m not going to because the long term benefits don’t outweigh the initial steep learning curve and gigantic drop in productivity it will cause. However, notice that I’m not sitting here writing articles about how horrible Dvorak users are, and how assbackwards and outdated Dvorak is, and how you’re stupid if you don’t use Qwerty. You know why? Because it’s a matter of preference, and should be respected as such.

    • @Tucker: oh, so the problem is that I’m writing an article about how the VIM users are horrible, because they jump in front of everyone to preach about it? Ok, then it’s settled.

      The point is that I would not recommend vim to a beginner, yet I’ve seen too many people doing just that. Their arguments: if you have this plugin and this and this and this and this you could do this. Which is silly. The point is that vim becomes a barrier to accessing programming when such people guide future developers.

      And that was the initial problem. Now, the second problem is that vim users are elitist and smug about their choice of editors. And I’m like “fuck no, you can use whatever, but I recommend an IDE, because you have everything there without need to make an effort, without the need to learn how to quit the darned editor. It’s simple, it’s what you know, go for an IDE”.

      From time to time I like to use vim, but I can’t for bigger tasks. I find it horrible for refactorings – again, I’m sure that with this and that plugin refactorings are fast and easy, yet I doubt that its results are proper.

      So that’s the story that vim elitists find hard to stomach. Developers ARE better off with an IDE, at all levels. End of story.

    • @Dorin
      “oh, so the problem is that I’m writing an article about how the VIM users are horrible, because they jump in front of everyone to preach about it?”
      The problem is that you’re pretending to write an article that explains your fears about Vim being taught to beginners, and attempts to convince these people to change their behavior, yet what you actually write is nothing but malicious vitriol describing how stupid you think said people are and how much you dislike their personal choices in tools. I don’t know about you, but as far as I can tell, pissing off your audience is a pretty poor way to change their minds about something. I would have been very happy with a thoughtful discussion about how introducing beginners to Vim can often scare them off of programming entirely or something similar, and how we should, as Vim users and teachers, be weary of this fact. What I got was a slap in the face by a whiny douchebag who clearly doesn’t know what he’s talking about. I want my proverbial money back. Of course, I’ve said all this multiple times already, but I know you don’t actually listen so why do I even bother.

      “Their arguments: if you have this plugin and this and this and this and this you could do this. Which is silly.”
      Why is it silly? I’d think an editor being extremely extensible would be a major plus, because it would mean you could actually do all those things. If all it could do was stuff that was built in then it’s a pretty shitty tool. Emacs especially takes this concept to the extreme: nothing is built in. This is great because it allows you to mix and match your tools, and your experience won’t be weighed down with tools that you don’t need, like it is in an IDE. And if there’s a feature you want that doesn’t exist, you can easily just write a plugin for it. Vim doesn’t go quite as far as Emacs does, because Vim does have everything Notepad++ has and some more built in, but if you want anything more than that, you use plugins. There’s nothing wrong with that. If everything you could possibly need is built into your editor, that’s a lot of interconnecting code for the developers to maintain, and there’s a lot higher chance that the product is going to be a complete train wreck. This is the idea behind the Unix philosophy of ‘every program should do only one thing, and do that thing really well’. The more complex your code is, and the more it tries to do at the same time, the more of a chance there is that it will suck. That’s why the best software products are often the simplest.

      “The point is that vim becomes a barrier to accessing programming when such people guide future developers.”
      No, I agree. I’m just explaining to you that pissing such people off is not going to make things better. And pissing other people off in the process … it makes me think you don’t actually care.

      “Now, the second problem is that vim users are elitist and smug about their choice of editors.”
      sigh. See this is what I’m talking about. Generalizing an entire group of people based on some bad experiences you’ve had in the past. No, not all Vim users are elitist and smug. Some Vim users are. Some non-Vim users are. Some people are elitist and smug. The thing is, a lot of people aren’t, as well. And including those people in your misguided whinings does not help your cause, to say the least.

      “And I’m like “fuck no, you can use whatever, but I recommend an IDE, because you have everything there without need to make an effort, without the need to learn how to quit the darned editor. It’s simple, it’s what you know, go for an IDE”.”
      … you mean :quit? :quit is how you quit Vim. Or :q for short. I guess if that’s too hard for you to learn then yeah, just stick with what you know. Don’t bother going to university either, they try to make you learn things there so you’ll just end up tiring yourself out. In fact, stop writing code altogether. Go work on an assembly line screwing toothpaste caps on toothpaste, or better yet, go live in your mom’s basement for the rest of your life. That way you can live your life ‘without need to make an effort’. Jackass.

      “I find it horrible for refactorings – again, I’m sure that with this and that plugin refactorings are fast and easy, yet I doubt that its results are proper.”
      You ‘doubt the results are proper’, what’s that supposed to mean? Refactoring is an extremely interactive process, sure you have tools to help you but ultimately the programmer is the one making the changes, so the programmer is the one who decides what the results are. What, do you just hit the ‘refactor’ button and hope for the best? Do you have any idea how terrible of an idea that is? I guess you don’t care though. After all, you’d rather not ‘need to make an effort’. Jesus, if I were your boss I’d fire you.

      “So that’s the story that vim elitists find hard to stomach. Developers ARE better off with an IDE, at all levels. End of story.”
      Cool story bro. So, just so I’m clear, let me recap your story: “Here’s why Vim should not be recommended to beginners”, “Installing plugins is hard”, “Vim users are jerks”, “Learning is hard”, “Effort is hard”, “Refactoring is hard”, “In summary, that’s why IDEs are better than Vim and every developer is better off with an IDE.” … no, I’m afraid that doesn’t follow. Sorry.

    • I doubt that dorin meant to say that all vim users are elitist smug jerks. But a lot are. If you try to tell many people about why an IDE is better than vim, many will tell you: you just don’t grok vim. If you haven’t spent ten years trying to master it, then you just don’t understand it. Of course, try telling them that they haven’t mastered Eclipse for a fair comparison.

      By parse code, I mean exactly that. All the cool IDE features are built around the IDE’s ability to have an AST representation of your entire codebase. It needs to be both fast and accurate. Parsing/indexing c++ is hard, so it’s never 100% perfect. But if the accuracy is even moderately away from 100%, it becomes almost useless. Eclipse’s parser/indexer is excellent, and on top of that it also has the best feature set for the useful things it lets you do, enabled by that AST representation. Our codebase is pretty complicated (templates, indirection, etc), Clion’s static error detector (finds errors in code as it’s written without compiling, extremely useful feature) had 100’s of false positives in files of a few thousands lines of source. When you have a false positive on every 10th line, that feature is now useless. In that same piece of code, Eclipse’s error detector had one false positive (on about 5000 lines of code) stemming from some trivial bug in how std::cerr and << are handled.

      As for multiple languages, I don’t want to get too far into this, as it’s off topic. But basically, there’s huge technical cost to interfacing between different languages, and there’s a cost for a single individual in spreading themselves thin. Even enormous companies like Google are probably 95% covered by just a handful of languages (Google AFAIK has only 4 official languages: C++, Java, Python, and Go, between those and Javascript variants I suspect it covers 99% of their LOC and daily work). Even more relevantly, a given job posting will rarely ask for more than a few languages.

      Anyhow, I’m quite willing to bet if you survey programmers at a variety of places, you’ll find that the vast majority of programmers will do at least 50% of their development in just one language, in a given week or month. And out of those, most will be doing it in a language that has a good IDE available.

      You say it’s all about different people needing different workflows, I think the exact thing that me and Dorin are saying is that for the vast majority of people programming e.g. C++ or python in vim, if they had an open mind and looked at it objectively, they would be using an IDE. But they don’t, because so many vim and emacs people treat their choice of editor as a religious matter. Worse, they have convinced themselves that they’re just uber programmers who naturally uber case about efficiency, use these tools because they’re the most efficient, and try to convince anyone who will listen. There are edge cases where using vim over an ide makes sense; needing to work over ssh, not spending long enough in one specific language, etc. But for the majority of developers working in today’s environment, IDE’s are a much better tool, and the main reason that a certain group of people hasn’t grokked that is not because they have such a special workflow, but because they can’t reason objectively anymore about the matter.

    • @quicknir: correct. I am a vim user, although not proficient, I still am a vim user. Not all are horrible jerks, but those that push it as THE ONE TRUE SOLUTION are that, and are inconsiderate as well.

    • @quicknir
      “I doubt that dorin meant to say that all vim users are elitist smug jerks.”
      You sure about that? Because he has never said ‘some vim users are elitist smug jerks’, or ‘most vim users are elitist smug jerks’, and he has also never said ‘some vim users are not elitist smug jerks’. Over and over he says, ‘vim users are elitist smug jerks’. If he had instead said ‘Japanese people are pedophiles’ or ‘women are extremely unintelligent’, I don’t figure you would be coming around to defend him because he didn’t explicitly say that all of them were such.

      “But a lot are. If you try to tell many people about why an IDE is better than vim, many will tell you: you just don’t grok vim.”
      If you try to tell people that IDEs are better than vim … they’ll tell you that you don’t understand vim … and that makes them smug jerks? I don’t follow. If something has a huge fanbase it’s clearly doing something right, and if you don’t see what that is, then that’s clearly because you don’t understand it very well. That’s okay, there’s nothing wrong with that. What there is something wrong with is running around telling a bunch of people that your IDE is better than the tools they choose to use. That makes the person using the IDE an elitist smug jerk.

      “If you haven’t spent ten years trying to master it, then you just don’t understand it.”
      If you think Vim takes ten years to master then you clearly don’t understand it. It only took me a month or so to start using all the keybindings well, and even before then I was decently good with it. Even the day after I started using it, I was just as fast with it as I was with my old editor, Geany. Sure, it seems overwhelming at first, but it really isn’t, unless you’re an idiot and try to learn it all at once.

      “By parse code, I mean exactly that. All the cool IDE features are built around the IDE’s ability to have an AST representation of your entire codebase.”
      Why would you ever need that? The only useful thing I can think of that you could do with something like that is get instant feedback about compiler errors/linting/etc, but unless you’re just a shit programmer you won’t make mistakes often enough for that to actually save you any time or effort.

      “Clion’s static error detector (finds errors in code as it’s written without compiling, extremely useful feature) had 100’s of false positives in files of a few thousands lines of source.”
      Sounds to me like their algorithms just aren’t very good yet. Of course with C++ it’s probably pretty easy, comparatively. I’ve been using IDEA a lot for Groovy recently, and I get a lot of false positive error checks because it doesn’t recognize a lot of the DSLs I’m working with. That tends to get annoying. I might as well just turn it off, nothing it tells me is ever an actual error anyway, and if it is I’ll just figure that out when I try to compile it.

      “there’s huge technical cost to interfacing between different languages”
      That depends on the language. A lot of languages are pretty easy to combine and use together. Embedding Lua in a C project, linking C and ASM objects together, writing Scala that uses Java libraries, interfacing Javascript in a browser with Groovy on a server, writing separate services in different languages and having them interact via some REST API, or just writing different programs in different languages and tying them together from a BASH script.

      “and there’s a cost for a single individual in spreading themselves thin.”
      Oh yes, because using more than one language a day really ‘spreads you thin’. What are you even talking about? There’s nothing exhausting or complicated about using different languages for different purposes. Even if there was, it wouldn’t be nearly as exhausting or complicated as trying to use a language for a purpose it wasn’t designed for. You of all people, being a C++ programmer, should understand this. You can write just about anything in C++, sure, but sometimes in order to do it you have to build tons of infrastructure and work around all the shitty static typing and god knows what else, and by the end of it all you’ve written five hundred lines of code and you could have done the same thing in Python in fifty lines. For me at least, the latter spreads less thin. I understand that a lot of the time there are still plenty of good reasons to choose the former, but in this particular example, for simplicity’s sake, let’s just say there isn’t.

      “I think the exact thing that me and Dorin are saying is that for the vast majority of people programming e.g. C++ or python in vim, if they had an open mind and looked at it objectively, they would be using an IDE.”
      Why? What’s objectively better about an IDE? Nobody on this post has actually given any real input as far as this is concerned, yet. Dorin has talked a lot about how he likes IDEs because he’s comfortable with them, and because he doesn’t like Vim’s userbase, and that’s about it. I guess you’ve discussed your Eclipse parsing/indexing, which, hey, if you find that useful, more power to you. But you also use Vim keybindings, which are pretty much the defining feature of Vim, so as far as I’m concerned you’re a Vim user.

      “But they don’t, because so many vim and emacs people treat their choice of editor as a religious matter.”
      I don’t know anyone who actually does this. I don’t know of anyone who actually does this except, like, Richard Stallman, and he’s an insane person.

      “Worse, they have convinced themselves that they’re just uber programmers who naturally uber case about efficiency, use these tools because they’re the most efficient, and try to convince anyone who will listen.”
      A lot of them seem to do this, yes. But at least as far as most of these people are concerned, if you actually get to know them, you start to realize that they just find the increase in efficiency or extensibility or whatever to be much more comfortable and freeing than what they were using before. I remember, before I started using Vim, I would look at the Vim people and wonder, ‘what’s the point? Aren’t all editors basically the same? As long as you get the job done it doesn’t really matter. These people just think they’re better than me.’ Then, when I started using Vim, I realized something: it’s actually possible to enjoy the act of using a text editor, not even for anything in particular, just the act of editing itself. And I realized that the reason I had felt the way I had felt was simply because I hadn’t enjoyed it, but I hadn’t noticed because it didn’t occur to me that it was something that could possibly be enjoyable. The same thing happened to me when I switched to Linux: before that point I wondered why there were all these elitist Linux people running around telling me how cool their operating system was, but once I actually tried Linux, I understood that they were actually right, and that just wasn’t a possibility that had crossed my mind before that point. Of course Vim users are going to try to convince anyone who will listen to use it. It’s like when you read a book that you really really really like, and you can’t stop recommending it to people, even people who don’t even like that genre, even to the point where they start getting annoyed at you. Most Vim users aren’t trying to be assholes about this. Some are, but most are just trying to share something with you that’s special to them, and they come across the wrong way.

      “But for the majority of developers working in today’s environment, IDE’s are a much better tool, and the main reason that a certain group of people hasn’t grokked that is not because they have such a special workflow, but because they can’t reason objectively anymore about the matter.”
      What is this about ‘special workflows’? I never said anything about that, at least I don’t think I did. I guess workflow is one example, but the thing that really matters the most, the most objectively important thing to consider when choosing a text editor, is personal comfort level. The more comfortable you are with your editor, and the less you fight it, the better your experience is. Believe it or not, this can make a huge difference in both how productive you are and the quality of your code.

      This is why I don’t like Eclipse: because every minute I’ve ever spent using it, it’s doing things that I don’t want it to do, or failing to do things that I do want it to do. This includes crashing so hard I have to reinstall it from scratch (fairly often), popping up a ton of extra useless information about my code that only serves to distract me from it, or having me rely on magic buttons that end up doing things I don’t expect or intend to do. Every time I run into something like this, I grumpily storm off to the preferences or to Google to figure out how to fix it. Sometimes this works, other times it doesn’t and I’m forced to just live with this ass-backward ‘feature’ for the rest of my life. A good example of this I think is the ‘workspace’ concept; I can’t just open files or projects anywhere on my disk, they have to be in special workspace directories that I have to switch between and each workspace has separate preferences, so I have to do a ton of extra work that I shouldn’t need to do every time I want to open a new or different piece of code. Because of these things and other similar shit, it takes me three times as long to get anything done in Eclipse than in Vim, even with all of Eclipse’s boilerplate generation and static code analysis and search features and interactive debugging and code completion and integrated docs and so on. On the other hand, everything in Vim is simple enough that it works exactly the way I want it to every single time, yet powerful enough that I don’t get slowed down by it, and the times I have to fight Vim are few and far between. I can only think of a handful of examples of Vim doing something I didn’t want it to, and every one of those times I could fix it easily with a quick google search or :help and a line in my .vimrc. I’ve been openminded about Eclipse many, many times (after all, the problem may just be that I’m approaching it incorrectly, as that’s the problem most people run into when attempting to use Vim), but until the day I realize that this is the case, I’ll continue to dislike Eclipse because it’s so uncomfortable for me, personally, to use.

    • @Dorin
      “Not all are horrible jerks, but those that push it as THE ONE TRUE SOLUTION are that, and are inconsiderate as well.”
      Wait … that sounds familiar …

      “Does it make sense for the modern developer [to learn Vim]? Not unless you don’t have a proper IDE.”

      “I would never recommend to anyone working without an IDE.”

      “Developers ARE better off with an IDE, at all levels. End of story.”

      Alright. So people who push Vim as ‘the one true solution’ are horrible inconsiderate jerks, but people who push IDEs as such are not. Got it.

    • @tucker Yeah, and people that say that cars are faster and better than carts are jerks. 🙂 Got it. 🙂

      Do you wonder why you’re trying so hard now? What are you trying to achieve? Why do you even bother? 🙂 Isn’t it too much of an effort? Can’t you see that your style of argumentation only brings discord but no result? 🙂

      That’s why people tend to say that all VIM users are jerks. They only see the ones that are.

    • @Dorin
      “Yeah, and people that say that cars are faster and better than cars are jerks. Got it.”
      Well yeah, as long as you’re comparing something objectively measurable, like speed, then that’s a little different. In that case, Vim has a faster start time and I can edit faster in Vim than in an IDE. That must mean Vim is objectively better than IDEs, right? Because it’s ‘faster’? No, it doesn’t work that way. And come to think of it, cars don’t work that way either. Cars are as much about comfort and use cases as text editors or anything else. I’d rather have something slightly slower if the alternative doesn’t have shocks and a radio and comfortable seats. I wouldn’t buy a Ferrari if I were planning to do any offroading with it. Bugattis are expensive and fast as hell, but they look terrible and they handle like shit so I wouldn’t buy one even if I could afford it. I suppose it’s still objectively better than a Ford Taurus. I suppose Eclipse is objectively better than Notepad. But you have discussed the power of Vim quite a few times, so clearly that’s not the comparison we’re making here. You’re not matter-of-factly stating that a hunk of gold is better than a heap of trash, you’re comparing two cars that are in the same league. And then you’re saying that because one is fully electric that means it sucks ass.

      Oh, right, I got on a bit of a tangent … what were we talking about? Oh yeah, the difference. The difference is, if you talk shit about a beat up rusted old Jeep, nobody’s going to argue with you, everyone knows that you’re right. Everyone agrees with you. Nobody takes offense. Now, let’s say the owner of that Jeep inherited it from his dead father. This man grew up with this car, knows this car inside and out, loves this car, even though it’s old and beat up and he can’t afford to take care of it very well. And you’re still telling him about how shitty his car is. Suddenly you’re a jerk again. Do you understand why? The only way you’re not a jerk is if there’s nobody to be a jerk to.

      “Do you wonder why you’re trying so hard now? What are you trying to achieve? Why do you even bother? Isn’t it too much of an effort? Can’t you see that your style of argumentation only brings discord but no result?”
      What the fuck are you even talking about? I’m just having a conversation, no trying or achieving or effort involved. I like to talk about Vim, so I come on your blog and talk about Vim, it’s as simple as that. I don’t see any discord, and I’m not expecting any result. If you want to make this into an argument then as far as I can tell I won ages ago, but the only result I’m expecting is for you to keep repeating yourself and saying the same shit over and over and over. After all, you’re a terrible listener.

      “That’s why people tend to say that all VIM users are jerks. They only see the ones that are.”
      Well then, those people are idiots for continuing to hang out with people they clearly don’t like. I’ve met hundreds of Vim users, and they’re all really cool people who don’t mind at all whether the people they meet use Emacs or Notepad++ or Eclipse or anything else. I’ve never in my life met the kind of Vim user you describe in your article. On the other hand, I know they exist because I know that every type of person exists somewhere, and I know that generalizing and saying that all Vim users are wonderful people would be just as stupid and ignorant as generalizing and saying that all Vim users are elitist smug jerks.

    • @Dorin
      “Do you have a tl;dr version? Because seriously, nobody cares about your wall of text.”
      Clearly that’s not the case, as this is one of my shorter ones and you’ve responded to the majority of my others. But if you insist, here’s the short version:

      You’re only not being a jerk if there’s nobody to be a jerk to. As long as someone is being offended, you’re being a jerk.

      It’s not about trying or bothering or achieving, I just like talking on the internet.

      Every Vim user I’ve met is a wonderful person, but it’s just as stupid of someone to assume that all Vim users are horrible as it would be for me to assume they were all wonderful. Every rule you ever make about people has an exception.

    • @Tucker: “as long as someone is being offended, you’re being a jerk”

      bwhahaahhahahahahahahahha :))) Never laughed as hard as this. :)))))))))

      Please, say it again :))))))))))))))))))))))))

  41. Advice like this is why we are increasingly faced with developers who know next to nothing about how software actually works. Just pick some brainless IDE and push buttons. Learning a real skill is not worth it. You will go far.

    • I often tell people that the best way to be a better programmer, besides practice and reading code written by programmers that are better than you, is learning to use as many different languages and tools as you can possibly get your hands on. Vim and emacs and IDEs included.

  42. You’re not saying anything new by saying Vim is bad for beginners, it’s true, I wouldn’t recommend it to anyone UNLESS they tell me that they feel like writing code is tedious and they’d like to find a better way. And not before warning them that they’ll feel slow for the first month.

    Vim is a tool for people that write a lot of code, so it doesn’t need to be approachable, the people that need it will force themselves to learn it anyway. That’s not to say it couldn’t be made more noob-friendly, I think there’s a lot of things that could be done to ease the transition, but since it’s not a mainstream tool, it doesn’t need to, and that’s why nobody has done it yet.

    • @Dorin
      “I prefer quality, not quantity.”
      lolwut? “People who write a lot of code” means “People who spend a lot of time coding”, as in, people who code for a living or as their major hobby or both. It does not mean “People who write 50 lines of code for something that could be done in three lines.” The editor of choice for those kinds of people I think would be an IDE, considering IDEs have built in tools you can use to generate a bunch of code without even having to type it. Vim, however, is good for people who spend a lot of time writing code, because it minimizes the tedious little non-coding tasks you have to do when editing. In other editors you spend a lot of time moving the mouse or hitting modifier keys or making selections manually or navigating enormous menus or whatever, and if you don’t code very much those things don’t matter all that much and Vim just isn’t worth learning, but if you code a lot, those things add up quickly and you end up spending a large chunk of your day doing tedious things, so minimizing those tasks is extremely helpful.

    • The main non-coding task you do is read code. For many languages (Java, C++, Python, and many others), IDEs have many useful tools that let you read code in different ways. Go-to definition is a tool that helps you read code. Type hierarchies, call graphs, include graphs, outlines, etc, are all code reading tools. Vim is far behind in terms of options and quality of those tools.

      The fact that you calmly assert that you spend lots of time using the mouse in other editors tells me you haven’t achieved a very high level of mastery in them. Eclipse has keyboard shortcuts for everything.

      I use Vrapper inside Eclipse which gives me excellent vim emulation. I enjoy using it tremendously, and it does generally save me a bit of time here and there. It’s only saved me a great deal of time in a few situations; when we decided to upgrade warning levels and I was fixing repetitive warnings, or when I occasionally want to align code e.g. to the = sign, and I’m able to effortlessly call a python script on some lines of text using ! in vim, and a few others. Most of the time, the savings are small, and this isn’t surprising, because the amount of time spent editing code are not that huge to begin with.

      Vim/emacs have very poor options for any tool that depends on actually having an AST of your codebase, compared to what’s available for IDEs. If you have a counterexample, I’m all ears, I’d love to have a good option for remoting in. YouCompleteMe is the best I’ve seen for VIM and it’s way behind Eclipse.

    • @quicknir
      “The main non-coding task you do is read code.”
      I guess I wasn’t as clear as I should have been. By ‘non-coding task’ I mean tasks that aren’t directly related to doing things with code. So, anything that’s not reading, writing, or editing code.

      “Eclipse has keyboard shortcuts for everything.”
      Does it? What’s the keyboard shortcut for copying the current paragraph? What’s the keyboard shortcut for deleting everything in a set of quotes? I can’t find those anywhere. Vim has those. And even the shortcuts that Eclipse does have require multiple modifier keys to press. I’d rather use the mouse than contort my hand all over my keyboard just to do something as simple as renaming a variable. Although you’re right, I’m not very good at Eclipse’s keyboard shortcuts, that is why I use the mouse. I think the problem is that they’re so hard to remember. There’s no rhyme or reason as to why they are what they are. Vim’s shortcuts were easy to learn because they’re all the first letter of the thing they do: ‘m’ is mark position, ‘f’ is find in line, ‘u’ is undo, ‘c’ is change text, ‘n’ is next search result … what’s next search result in Eclipse? Ctrl-k? Um why? How am I supposed to remember that shit? So yeah, the bottom line is Vim’s keybindings can do more and are easier to remember and use. If you don’t have Vim bindings at your disposal, you might as well just use the mouse.

      “I use Vrapper inside Eclipse”
      Then you do have Vim keybindings at your disposal. At least partial support for them. What are you doing praising the default Eclipse bindings if you don’t even use them? Now you’re just being silly. And yeah, as I’ve said in another post, I use IDEA with IdeaVim for work. I still prefer actual Vim.

  43. It’s not about Vim or Emacs, its about what you are fastest with to develop. I am about 5 to 10 times faster with Emacs than VS 2015, and about 20 times faster than I am with Qt creator unless I am making a Qt GUI project.

  44. I use vim every day at work. Really have tried to trade it for some IDE but I sort of hate all of them if it comes to C/C++. I felt Atom was greatly suited for my needs but it’s still buggy as hell and started to get really bloated in newer versions.

    Speaking of which. If author thinks vim/emacs are “difficult” and “counter-intuitive” he should try new Visual Studio (or any for that matter). It really goes beyond my reasoning how something that cost so much can be so bad for productivity, or maybe they should just drop C/C++ and other non-microsoft languages support and just stick with C# and all .Net thingies. Since as far as they’re concerned IDE works just fine.

    Still, I wouldn’t recommend vim for doing Java for example.

  45. I’m learning VIM because I’m fed up of buggy, bloated IDEs that don’t specifically target the languages I use (C/C++ and some Objective C).

    I use Visual Studio for my day job. I’ve gotten it to the point where it’s usable but it took years of tweaking and trial and error and a lot of these tweaks break when we upgrade. Some of the plugins I rely on (like Visual Assist) are expensive commercial products. It’s a patchwork of overlapping extensions. The IDE is clearly built for the .net languages. It also freezes/crashes on a regular basis.

    XCode on the Mac used to be OK but since version 4 it’s been a joke. Apple have tried to streamline it to appeal to the lowest common denominator and it’s so focused on iOS development and swift that’s impossible to understand what’s really going on.

    CLion is written in Java so that’s con right out of the box.

    Eclipse is just slow and horrible.

    QtCreator had promise and was refreshing for a while but it’s still bare boned in a lot of areas and suffers from frequent crashes and questionable design choices. It’s obviously targeted at Qt/QML development. It’s also written with Qt (obviously) which isn’t great on Mac.

    I’ve actually been really impressed with VIM so far and some of the plugins like YouCompleteMe are just amazing.