Built-In Vim Autocomplete (github.com)

This is classic "string-based" autocomplete. It completes based on strings it knows about but doesn't take into account the context. I've used for years but yesterday I realized that since Vim version 7 there's a more intelligent kind of autocomplete triggered by C-x C-o that is context-aware. It can complete object methods, HTML tag attribtes, CSS properties, etc. For info:

    :help new-omni-completion

If you have a tags file set up, vim omnicomplete (<C-x><C-o>) for C and C++ (at least) will also be able to complete struct/class members and other context sensitive.

Additionally, I set the user complete mode (<C-x><C-u>) to use vim's built in syntax complete (`:set completefunc=syntaxcomplete#Complete`), which is super helpful with e.g. config files because Vim is aware of all the available completion options.

Of course there's filename complete too (<C-x><C-f>).

These three modes can get some intelligent completion done but quite frankly the default local keyword completion covers 90% of my use cases.

I made a plugin [1] similar to this which offers more options when you press the Tab key. For instance, if you're typing a file path, you get Ctrl-X Ctrl-f completion (vim's file path completion) instead of the regular keyword completion. And if you type a period (configurable) and press Tab in filetypes like C, Python, Ruby, etc, you get omni completion (vim's semi-intelligent completion, which offers methods on classes, looks in ctags files, etc).

The great thing is that I was able to do this in less than 100 lines of code, and I love using it myself every day at work. Just goes to show that Vim has a pretty good completion system already and you don't need to use some bloated plugin system like YouCompleteMe or Neocomplete.

[1]: https://github.com/ajh17/VimCompletesMe

I got that one some time ago from https://github.com/garybernhardt/dotfiles/blob/master/.vimrc... which offers several other useful functions and settings.

  function! InsertTabWrapper()
        let col = col('.') - 1
        if !col || getline('.')[col - 1] !~ '\k'
                return "\<tab>"
        else
                return "\<c-p>"
        endif
  endfunction
  inoremap <expr> <tab> InsertTabWrapper()
  inoremap <s-tab> <c-n>

I had something like that in my vimrc for some time (snippet posted here: https://vimrcfu.com/snippet/222), using omni-completion when set in the buffer and keyword completion otherwise. Then, I developed the idea into a plugin that retains the minimalistic spirit, but it's much more flexible: https://github.com/lifepillar/vim-mucomplete.

That was meant to represent hitting Ctrl-x then Ctrl-f without letting go of the Ctrl key.

You mean `Ctrl-xCtrl-f`? That's `Ctrl-x Ctrl-f`. In terms of how it parses, after `Ctrl-`, the next token must be a single character (a key) is accepted. So `Ctrl-x` completes that particular accord and `Ctrl-f` is the accord following it.

Have you tried YouCompleteMe? I'm surprised you didn't mention it.

I switched to Evil mode and after a year I love it. I wrote the book to help me learn more about it!

I used emacs for 20 years. Around about 2007 I started doing all of my development on a tiny netbook and emacs was using too much memory. I switched to vim. It took me a good year to get used to it, but now I'm hooked on that way of thinking. About a year ago I switched back to emacs with evil mode. It is close enough to vim that I can barely tell the difference. If you are already familiar with emacs and have a setup that works for you, then switching to evil should be less painful than someone switching from vim.

I think the biggest thing to accept is that you will not be proficient with your editor for quite a long time. I recommend practicing with vim tutorials until it feels reasonably good before taking the plunge entirely. One very important thing is to keep looking for efficient ways to work with it. It's a bit like emacs in that if you ever think, "Oh, this is just painful. There must be a better way", then there is almost guaranteed to be a better way. Stop, find out what it is. Practice it.

My last piece of advice is that vim-style editing is a little bit different that emacs-style editing (at least for me). With emacs, I find that I memorise keybindings and practice using them. With vim, it's much more about the context -- when you are in situation X, you do this kind of thing. So it needs more practice (again IMO). However, once you have your brain oriented (orientated? :-) ), there is this sense of freedom. You are working with larger blocks of abstraction, rather than just the character level. Some people feel this is more efficient (i.e. faster), but I'm not sure. For me it's rather that it is closer to what I'm actually thinking when I'm programming. YMMV and I should warn you again that it takes considerable practice to get to the point where it starts to feel good.

I find a plugin (mu-complete https://github.com/lifepillar/vim-mucomplete) which makes use of vim's built in completion makes my life that little bit easier.