I really want to learn either Vim or Emacs but I've never been able to decide which one to learn. Every time I've tried to search about this topic I end up in petty wars. Help?
(Disclaimer: I am a happy Spacemacs user, and it would take a lot to pry it away from me.)
I'd recommend learning vi, so you can learn how awesome modal editing is. Then, learn Emacs' basic commands for line editing (so as to make readline apps easier to work with). Once you've done that, evaluate whether a (Neo)vim with plugins or Spacemacs setup is better for you, then choose one of those.
- *-mode (specific syntax highlighting, commands, etc. based on project or task)
- edit/save remote files via built-in TRAMP 
- built-in plugin manager (interactive, or via emacs init config)
- MELPA 
- Non-blocking (e.g., run tests in one buffer while editing source in another)
- client-server approach (neovim adopted this, but emacs has had far more time to work out the kinks)
The main reasons I stay with vim are:
- already committed to vi-like muscle memory (and evil-mode, while admirable, doesn't cut it)
- no translation of VimL configs and plugins to Emacs Lisp
- many plugins for languages, frameworks, etc. which I use daily are severely out of date in emacs (and I'm too lazy to maintain them myself)
Do you use neovim?
Use vim, learn vim all the way. If/when you're working on an "old" vi (e.g. the one in busybox, for embedded developers), you'll need to drop some of the more advanced stuff, but you'll still be able to do what you want, edit some config file or such, though it may feel a bit awkward at times.
But when you're doing the heavy editing, you really want to use all of vim.
Your advice is very misleading in 2016.
I don't think there is an active vi codebase, vi is actually vim in compatibility mode in most operating systems.
The main one is the concept of composability  - in vim, you're speaking a mini-language. You have commands (delete, copy, make uppercase,...), and a number of movements (right, down, to the next occurrence of a word, to line 27,...) or objects (word, line, paragraph, html tag, text within quotes, ...) to work on. These can be combined in any way you like, any command can be applied to any movement or object. So if you have a plugin like vim-angry that adds a "C-style function parameter" text object, all the commands you know can be applied to that. In contrast, in emacs, you have a number of commands (kill-line, kill-word, ...), and that's it. You have to get by with those. If they didn't implement the command you'd like to use, tough luck.
A second (minor) reason for me is that I work in the embedded software world, and usually on an embedded linux, there's at least some variant of vim or vi available, while emacs is very rare.
Take my advice with a grain of salt : I've never really used emacs, so I can't compare from first hand. From what I've heard, emacs is also a very good editor. To me, the question "should I use vim or emacs" is more or less the same as "should I use firefox or chrome" - I'm a chrome guy myself, but I don't consider firefox to be crap, nor its users to be idiots. Internet explorer on the other hand,...
So my advice : learn vim. And if you don't, learn emacs. Just learn to use either one properly, and you'll be way faster at editing than people who don't use those.
 a.o. https://medium.com/@mkozlows/why-atom-cant-replace-vim-43385...
So you just need to implement a bunch of selection commands to get Vim-style composability. I think lots of these modern text editors like sublime or atom come with select word, select parenthesized expression, select paragraph, etc. If the editor is extensible you can define new selection commands and compose them with the existing commands that operate on a region, just like Vim. Emacs certainly has a bunch of marking commands.
The extra commands you mentioned in Emacs (kill-word, kill-line, etc.) are just for convenience: Shortcuts for common cases. In Vim you can delete to the end of the word with dw. In Emacs you could also do a 2 keystroke solution: do mark-word, delete-region (you could use backspace, Control D or delete for that second second thing since they "operate on the region of the selection is active", so C-@ <backspace> would do it). Unlike Vim you also have the option of a single chord with the convenience command kill-word.
But the "select text and then apply command", as I understand it, still has a major drawback compared to vim's way of working : the dot-command. In vim, you go "daa" (delete an argument - i.e. delete the argument, including the comma which separates it, if you have the vim-angry plugin). Then you move to another argument, you just press dot, and the same thing happens.
Also, does the selection thing accept counts?
1. Yes, the ability to repeat with dot is advantage of the Vim model. Emacs just repeats the command part not the marking part too, not as useful as dot in Vim!
2. In Emacs every command accepts counts, just like Vim. Textadept doesn't offer counts, I believe. I think counts are probably an advantage of Vim and Emacs over most(?) other editors.
3. About Vim having more motions & text objects: Probably, but Emacs is close. Without extra packages you have: words, symbols and S-expressions (the names come from Lisp but these do something sensible in most languages: Symbol is usually identifier and S-expression is something like delimited expression: A string, a parenthesized expression, a block in curly braces or brackets, etc.), lines, sentences, and paragraphs. Texts packages add other targets like LaTeX environment. One thing definitely lacking in Emacs is that Vim usually offers two variants that differ slightly at the ends (like w vs e, or i( vs a(), those minor variations are pretty useful.
My point is just the saying other editors don't have the ability to combine commands with different things to operate on is obviously false, and claiming is unlikely to convert anytime to Vim. Instead Vim bloggers should focus on how Vim makes the basic composability idea even better with things like counts, repeatability of composed commands, and richer set of selection commands.
Why Atom can't replace Vim: https://medium.com/@mkozlows/why-atom-cant-replace-vim-43385...
I don't think the link you have addresses my point at all.
That you can build up sophisticated actions just by knowing the primitives and text objects is the point, right? And not having to memorize different commands and different selections.
From the article:
But now let’s look at delete commands. Let’s say you want to delete a word, delete to the end of the line, delete to the end of the file, or delete to the end of a paragraph.
Emacs only has two of these functions: kill-word and kill-line. Atom has the same two, more or less: deleteToEndOfWord() and deleteLine().
Vim, though, is different. Vim only has one command: d, which is “delete.” What does it delete? You name it, literally. The d command gets combined together with those commands for movement: dw deletes to the next word, d$ to the end of the line, dG to the end of the file, and d} to the end of the paragraph.
This is where Vim’s composability leads to its power. Emacs and Atom don’t have commands for deleting to the end of a file or a paragraph — even when they have commands to move to those places. But in Vim, if you can move to a location, you can delete to that location.
And composability is about more than just power, it’s also about learnability and consistency. The command for copying text in Vim is y. Do you know how to copy to the end of the line/file/paragraph? Of course you do: It’s y$, yG, and y} respectively. The command for increasing the indent is >, so you instantly know >$, >G, and >}. Convert to lowercase is gu, so… sure enough: gu$, guG, gu}.
Vim normal mode grammar: command motion-or-textobject
Other editor's grammar: select-a-region command
(Also, Vim visual mode grammar: select-a-region command)
Emacs has lots of command that can select a region. They tend to be called mark-something. There are commands for selecting words, sentences, paragraphs, function definitions, S-expressions (the name comes from Lisp but they're defined to be something useful in every language, usually something like "any delimited construct in the language --strings, blocks, array literals, etc."). Once you select something you can apply many actions to it: you can delete it, uppercase it, rot13 it, sort the lines in it, wrap it in parenthesis, etc.
Maybe what tripped the author up is that additionally Emacs has other commands like kill-word, kill-line that are shortcuts for common combinations of a motion and a command. The author is correct in saying that these convenience commands are not composable, but they're nice shortcuts to have (and by the way, contrary to what the author says Emacs does have a kill-paragraph command).
So you to delete a word you can do:
Emacs composable style: M-@ C-D (that is, mark-word delete-
Emacs shortcut: M-D (kill-word)
Atom composable style: Option-Shift-f backspace
Atom shortcut: Option-d
(I got the Atom ones by Googling, I don't if they are right, but if they're not, I'm pretty sure correct ones exist: Atom has both a composable way and a shortcut.)
Vim propaganda should stop saying other editors lack composable commands. Even notepad.exe lets me use any of its paltry motion commands[^2] available to select something and then use a generic delete command to delete whatever I selected. "Composability" is the default mode of operation of most text editors.
Vim propaganda should focus instead on the very real advantages than Vim's command model has. For example:
- dot repeats the whole command/motion pair. This is fabulous!
- Vim has counts so you can delete 9 words just as easily as 3 words. (Emacs also has them, but lots of editors don't, and they're superhandy.)
- Vim has lots of little variations of the motions and textobjects so you can pick exactly what you need, other editors tend to have fewer. For example, for words, Vim has w, e, aw, iw (and probably others I'm forgetting) which are related but a little bit different.
(Also, personally I think Vim bloggers should recognize that those non-composable commands like kill-word are nice optional shortcuts, that are actually a tiny advantage other editors have over Vim. Try playing VimGolf in Emacs --using the nice vimgolf Emacs package, because of course Emacs has a package for that-- and you'll see what I mean.)
[^1] OK, techinically C-D is delete-forward-char in the default keybindings, but when a region is active it acts as delete-region.
[^2] It's limited to character, word and line, I think. But people forget even the lowly notepad.exe has word motions (all text widgets on Windows do).
In vim, the most common way to delete a word is also the composable way, and also the shortest (just two keys). In emacs, most people probably learn the shortcuts first, so they don't have the muscle memory for the composable style. The composable style is also two modifier keys longer.
So in emacs, first you learn it the "regular" way, with all the shortcuts, and then when you want to learn composability, you have to relearn all sorts of basic things, and spend more keystrokes, to have that.
In vim, you've learned some basic commands (dw, c$, yia, ...), and then I tell you about composability, and you understand how you can combine all those commands and movements you already know :-)
I wish Emacs in particular took composability a little more seriously. Probably combining selecting an acting into a single repeatable command by default would be too un-Emacsy (after all, macros are very lightweight and there is evil mode), but it would be great to have all the fine-grained selection commands that Vim has. For example, AucTeX has a command to mark a LaTeX environment, but it also should have what Vim would call "inner LaTeX environment". As a more basic example, I wrote my own mark-line command because what I want to do with lines isn't always kill them! With builtins I think the best way to mark 5 whole lines starting from the one you're one is C-a C-SPC C-5 C-n, which is awful. With a mark-line command you just do M-5 M-L (depending of course on what you bind it too).
There have been attempts to bring better composability to Emacs besides Vi(m) emulators, in particular in a non-modal way. But the ones I've tried haven't fully convinced me. It's definitely possible to do it, but doing it properly might be a major undertaking. Maybe I should just start using evil again.
I then discovered kakoune and liked its design. I started getting familiar with it and using it more and more, and I think its core is much more solid than vim/emacs. It definitely doesn't have the same community support and plugins but it's already quite feature rich.
Then, if your friends use emacs, use evil-mode because vim is the best.