
A Good Vimrc (2014) - basename
https://dougblack.io/words/a-good-vimrc.html
======
wodny
I don't believe it's possible to have a good vimrc without really grasping
some elementary concepts like movements, operators, registers, windows etc. I
have recently watched all the Drew Neil's VimCasts[1] and after just a couple
of hours I've realized I was missing a lot for at least 10 years. There is
also quite a good presentation on YouTube by Max Cantor "How to Do 90% of What
Plugins Do (With Just Vim)"[2]. Instead of treating a single vimrc as the best
one it's useful to skim through dotfiles and plugins of some influential vim
users like Drew Neil[3] and Tim Pope[4]. BTW VimCasts are accompanied by a
book. The second edition[5] includes changes introduced by Vim 8.0.

[1]: [http://vimcasts.org/episodes/](http://vimcasts.org/episodes/) [2]:
[https://www.youtube.com/watch?v=XA2WjJbmmoM](https://www.youtube.com/watch?v=XA2WjJbmmoM)
[3]:
[https://github.com/nelstrom/dotfiles](https://github.com/nelstrom/dotfiles)
[4]: [https://github.com/tpope](https://github.com/tpope) [5]:
[https://pragprog.com/book/dnvim2/practical-vim-second-
editio...](https://pragprog.com/book/dnvim2/practical-vim-second-edition)

~~~
rcdmd
I would also recommend Daniel Miessler's tutorial.[1]

[1]:
[https://danielmiessler.com/study/vim/](https://danielmiessler.com/study/vim/)

------
lifthrasiir
> Don't put any lines in your vimrc that you don't understand.

Actually true for most human-configurable setting files.

~~~
divbit
I sort of disagree with this and think one should extend in the opposite
direction- to keep sharp, have an RNN generate some plausible config options /
shell commands, and append them to the bottom of your vimrc / bashrc on
startup. This results in sort of like a 'chaos monkey' of coding, to prepare
you for when real emergencies pop up.

~~~
afarrell
Huh? The point of a Chaos Monkey is to simulate failures that might happen in
real life. How does this do so?

~~~
divbit
Don't tell me you've never accidentally rm -rf'd something important

~~~
iamdave
Don't tell _me_ your default method for deleting files is to carelessly throw
'rm -rf' at the issue...if it's "important" and you're using -rf, a part of me
thinks "you deserve whatever happens"

~~~
divbit
I was joking in both comments (clearly running arbitrary shell commands on a
personal computer is a terrible idea), but it's not like a careless rm -rf has
never happened before

------
syncopatience
I wonder why text editor preferences are so personal. I use the same editor
and probably 90% of the same config as this guy and was nodding along until I
saw he remapped B and E. Horrifying! Those are fundamental motions.

~~~
Anthony-G
I’m always surprised at the number of people who recommend mapping `,` as
their Leader key; it’s almost as useful as its counterpart, `;`. I suspect
that such people never learned vanilla Vi and use `f`, `t` and related line
movement commands.

When I learned Vim, I started with the `vimtutor` tutorial. At the end of the
tutorial, it suggests _Learning the Vi Editor - by Linda Lamb (O’Reilly)_ [1]
for further reading. I found this book to be excellent for providing a solid
grounding on Vi – and its descendants such as Vim. For a while, I constrained
myself to using Vim in Vi-compatibilty mode before using the many wonderful
features provided by Vim.

I try to keep my vimrc as lean as possible so that I’m not reliant on having
it available (even though I have it in a Git repository on my VPS) and it’s
only in the last couple of years that I’ve started adding plugins to it
(Syntastic and Unicycle).

[1]
[http://shop.oreilly.com/product/9781565924260.do](http://shop.oreilly.com/product/9781565924260.do)

~~~
edanm
"I’m always surprised at the number of people who recommend mapping `,` as
their Leader key; it’s almost as useful as its counterpart, `;`. I suspect
that such people never learned vanilla Vi and use `f`, `t` and related line
movement commands."

I've been using vim for years, but I completely disagree with your statement.
I rarely find the "," key useful, so to me it was a no-brainer to switch to
using it as the leader. I just have ",;" mapped to the functionality that ","
used to do.

I use ";" all the time, but searching backwards just barely comes up. Usually,
I'll hit "home" and then repeat my "f" search if I need it.

~~~
Anthony-G
Thanks for different perspective (and to otterpro and tasuki). I use `;` much
more often than `,` but I still find the `,` useful when I’ve gone past the
position I want to go to, e.g., typing `5fx` when I should really have have
used `4fx`.

------
inetknght
The literal worst of vimrc is the _default_ settings of many Linux
distributions these days. Colors are fine, but _behavior_-changing stuff is
not. I would be happier if package installers included a brief configurator as
part of installation.

Do you want to use tabs when you press tab, or spaces? If spaces, then _how
many_?

Do you want to automatically (infuriatingly IMO) continue comments and
completely wreck the ability to paste text without also _telling_ vim that you
intend to paste via the `set paste` command?

Simple stuff like that, you know?

~~~
iopuy
Ahhh good old 'set paste'. The setting that has turned away so many. When I
watch a novice coworker struggle with vim, the breaking point usually comes
when they try to paste directly into insert node. That may be the most
valuable of all commands in this discussion.

~~~
patrec
Does vim 8 still not have bracketed paste by default?

[https://cirw.in/blog/bracketed-paste](https://cirw.in/blog/bracketed-paste)

~~~
iopuy
Bracketed paste appears to be a third party plugin. I have no reason to
believe it is has been rolled into an official Vim release.

------
nichochar
I've been using VIM for a while, and I'm always delighted to read articles or
examples of good .vimrc's, but this one tops them all, because of the perfect
balance of cool features and concise explanations. Good job, OP, what a
wonderful blog post, I learned a couple nice things too!

------
Godel_unicode
Now just add the section about uploading it to your GitHub so all new servers
get setup with a simple git clone, and any new changes can be propogated
around with push/pull.

~~~
kornish
For anyone interested in this topic, [0] contains the best setup I've found
for storing dotfiles in a git repo, then linking them with GNU Stow. Steps are
just:

    
    
      git clone https://github.com/me/my-dotfile-repo
      cd my-dotfile-repo
      stow --target=$HOME zsh
      stow --target=$HOME vim
      ...
    

Elegant, cross-platform, easy to remember.

[0]: [http://brandon.invergo.net/news/2012-05-26-using-gnu-stow-
to...](http://brandon.invergo.net/news/2012-05-26-using-gnu-stow-to-manage-
your-dotfiles.html)

~~~
jyrkesh
Sorry if this is a super naive/dumb question, but why wouldn't I simply write
a "build" script that copies files out of my dotfile repo to where they're
supposed to go?

~~~
jck
1) It's cumbersome, and you'll need to specially handle things like deleting
files. I personally wouldn't be comfortable having a homebaked script rm stuff
in my home directory.

2) By using copies instead of symlinks you'll need to run your script
Everytime you make changes and be careful to edit only your clone instead of
the target location.

------
preek
Since this article is written in kind of a "literate programming style", I'll
plug and share my Emacs config that is actually written in literate
programming:
[https://github.com/munen/emacs.d/blob/master/configuration.o...](https://github.com/munen/emacs.d/blob/master/configuration.org)

Nice documentation like this fine blog post for free^^

~~~
nothrabannosir
If I understand it correctly you generate the program from that file by
removing all the non-code text, right?

This is very well documented , but not "actually" literal programming. It's a
losing battle over this definition but since you said actually I'll go for it
one last time :p

In literal programming, the order of the explanation dictates the flow of
text. Conversely, well documented source code follows the order of the
program.

 _The literate programming paradigm, as conceived by Knuth, represents a move
away from writing programs in the manner and order imposed by the computer,
and instead enables programmers to develop programs in the order demanded by
the logic and flow of their thoughts.[2] Literate programs are written as an
uninterrupted exposition of logic in an ordinary human language, much like the
text of an essay, in which macros are included to hide abstractions and
traditional source code._

\-
[https://en.m.wikipedia.org/wiki/Literate_programming](https://en.m.wikipedia.org/wiki/Literate_programming)

Literate programming in this specific case would include a big overview of the
entire file somewhere with references to each section. These would then be
pulled in and included at compile time.

~~~
gnuvince
> In literal (sic) programming, the order of the explanation dictates the flow
> of text. Conversely, well documented source code follows the order of the
> program.

org-mode supports noweb-like chunks, so you can do "real, Knuth-like" literate
programming. It just makes little sense in the case of configuration files
because they're just a collection of mostly-independent bits.

~~~
preek
Since configuration in Emacs mostly is code, imho it makes a lot of sense.

~~~
gnuvince
It's code, but most of it is simply (use-package ivy ...) or (setq tab-width
3.14), where's the value in chunks? The typical Emacs configuration doesn't
contain data structure definitions, algorithm implementations, or error
handling that can be more appropriately reorganized for a reader.

------
eugeneionesco
This article would have been much better with screenshots.

------
godmodus
Good write up. Ive been looking into Now this might sound like heresy but I've
been considering moving to emacs lately and using evil mode.

The thing that gets me is vim's lack for auto completion for stuff like scala.
Has anyone managed to set that up?

~~~
japano1se
Have you considered spacemacs? [http://spacemacs.org/](http://spacemacs.org/)

I've been using it for a month or so. It's very easy to set up and configure,
and it's built with evil-mode in mind. It also has very good modes for
development - I use it for Go and everything including completion and hinting
function signatures worked right out of the box once the Go layer was
installed (which is one line in your .spacemacs)

~~~
oblio
My problem with Emacs, I'm a bit of a visual person and Emacs doesn't have
tabs. There's all sorts of half baked tab system that don't do what the real
thing in Vim does.

And everytime someone I ask about this someone point me to some "superior
paradigm". It ain't superior if I don't like it :)

~~~
untoreh
I think I have got tabs allright in my emacs, although a tab-layer would be
definitely appreciated in spacemacs

------
amingilani
My Chrome on Android is getting a certificate error for this website.

------
htor
The best vimrc is no vimrc at all.

