How I Vim

Karl Yngve Lervag

Sun, 11 Dec 2016 00:00:00 +0000

Who are you and what do you use Vim for?

My name is Karl Yngve Lervåg. I’m a research scientist at SINTEF Energy Research in Trondheim Norway. My main area of research is the study of flow multiphase flow phenomena and thermodynamics.

I use Vim for many things: writing papers (with vimtex), development of numerical codes for solving scientific problems (mostly python and Fortran), writing notes (vimwiki and markdown), writing scripts (bash, zsh, python).

I started using Vim during my undergraduate studies, somewhere around 2003-2004. I learnt early on to use motions and commands, but I have to admit that I was slow to learn about text objects. When I did, it really was a revelation, and I begun to realize that Vi/Vim is like a language for editing text. For me, this has become an essential thing, and today I use modal settings for my terminal shell (zsh) and for my web reader (google chrome with cvim). Anyway, I’ve learnt to use Vim obviously by using it a lot, and through reading custom configurations. I think the help system is very good, and I use it almost daily. I learned to write vimscript through contributing to plugins like LaTeX-Box and through writing my own LaTeX plugin vimtex.

When it comes to versions of Vim: I mainly use gvim, but of course also terminal vim when necessary. I’ve looked into neovim: I like the idea, but with age has also come some conservative attitudes. Vim works for me, and the combination of vim with a terminal is great. So far there are no clear reasons to switch. I use Arch Linux, and as such I tend to use very recent versions of software such as Vim. Today this means 8.0.86.

I have to admit that I have looked into Emacs. It is clearly more powerful and customizable, e.g. because of elisp. I really (really) like Lisp, although I have not had the opportunity of working with it a lot. I think Spacemacs looks very promising, as it combines the good from Emacs and Vim. Also, org-mode is very tempting. There are no real alternatives to it for Vim, even though vimwiki is OK. However, Vim really does work very well for me. After I’ve become quite proficient with vimscript, I find I can typically add/implement features that I want without too much work.

Introduce us to your Vim config.

My configuration consists of my vimrc file, where plugins are loaded with the well known and fantastic vim-plug. I also have a lot of minor additions in a personal “plugin”. Thus my configurations looks like this:

dotvim
├── bundle
├── personal
│   ├── after
│   ├── autoload
│   ├── ftdetect
│   ├── ftplugin
│   ├── indent
│   ├── plugin
│   └── syntax
├── snippets
├── spell

If I clone my dotvim repo, then do cat **/*.vim | wc -l, I find I have 2371 lines of Vim configuration. Most of it is in my vimrc file, which currently is at 1096 lines. Today I think it is a little bit too heavy, and I often try to strip away things I don’t need. I have 59 plugins installed, but I would guess that about 10 of them are not really that useful.

When it comes to options, I think I use rather standard settings. I wrote my vimrc from scratch some time long ago, and I’ve tried to update it with the idea that I should always know what I’m doing.

I’ve relatively recently reverted from using a dedicated statusline plugin, as I have found both that I can easily define my own statusline (and tabline, but I rarely use tabs), and that I want to keep it very simple and distraction free. The latter has become pretty important for me, so I also change the default fold text to remove dashes, I use the cursor to indicate mode, and I change some highlighting options to avoid underlines.

A recent update to my configuration was to disable cursorline when vim focus is lost. Today I use the following autocommands, which I think provides a nice way to indicate where the current focus is.

" Only use cursorline for current window
autocmd WinEnter,FocusGained * setlocal cursorline
autocmd WinLeave,FocusLost   * setlocal nocursorline

I have a few mappings, and I use <space> as my leader key. One of the most important mappings is probably jk -> <esc>, which I like because I now almost never need the <esc> key. I know all the alternatives (move escape to caps lock, etc), but I find this is enough for my needs. Other important mappings to me are gb and gB to change buffers and <leader>ev to open my vimrc file.

Finally, when it comes to plugins, I want to draw attention to junegunn’s vim-easy-align. It provides a very convenient command to interactively tabularize text based on delimiters, :LiveEasyAlign. I don’t use it very often, but I smile every time I do! I also find vim-sandwich by machakann great: It provides both text objects and “verbs” for manipulating surroundings. Opposed to surround.vim by tpope, it allows very advanced surround definitions.

Further, I think Konfekts FastFold plugin is good: It solves the problem with Vim’s slow folding for syntax and expression foldmethods. I also have to mention tpopes fugitive, as well as Shougo’s neocomplete and unite and welle’s targets.vim. Great plugins!

Tell us the story behind vimtex.

vimtex is a plugin for writing LaTeX documents. LaTeX is a system for typesetting beautiful documents, and is very much favored by mathematicians and physicists e.g. because it is easy to write equations. I use it to write my papers, as well as many other things. Although, I should mention that today I use markdown for simple things, because it is more convenient.

I had been contributing to LaTeX-Box for quite awhile before I started on vimtex. I found it was difficult to solve issues, and I was thinking it had to do with the structure of the code. I thought that it shouldn’t take too long to rewrite the code and make things better, and so on a plane to Iceland I started writing vimtex. It began as rewrite of LaTeX-Box, but it didn’t take long until I had updated, changed, moved or removed almost every line.

The core idea was to have a more consistent code structure. And even though there are things I see today that I should have done differently, I think it has been a success. With vimtex I now have a LaTeX plugin that does what I want. It has relevant text objects and good commands for compiling and viewing documents. I think the features are getting close to full, although there might be some improvements to format expressions and motions in the future. Else I think my efforts will mainly focus on solving issues and fixing bugs (strange how there always seem to be some bugs remaining).

The main issues today concern support for Windows, I think. I don’t really use Vim on windows, and even though I do have a Windows computer where I can test things, it takes much more time for me to do it. And time is a thing I really don’t have much of these days. So, as the plugin is getting more popular, so are issues related to running vimtex on Windows. I hope and think that I am getting closer to a version that should work well for most people, but I have realized that I need to add a section in the docs with troubleshooting for Windows. Some things are just too difficult…

I have to say that even though I have mainly developed vimtex all by myself, it would NOT have been possible without the help from users who open issues and help solve them. I think I have been lucky in that there are many users who take their time to write good and thoughtful bug reports and feature requests. This can not be stressed enough: vimtex would not have been as good as it is today without contributions from fellow Vim users who write LaTeX documents!

command! MergeMode :call s:setup_merge_mode()

function! s:setup_merge_mode()
  if !&diff | return | endif

  " Create straightforward mappings
  nmap     ]] ]n
  nmap     [[ [n
  nnoremap do <nop>
  nnoremap <silent> dp        :diffput 2<cr>
  nnoremap <silent> dol       :diffget 1<cr>
  nnoremap <silent> dor       :diffget 3<cr>
  nnoremap <silent> do1       :diffget 1<cr>
  nnoremap <silent> do3       :diffget 3<cr>
  nnoremap <silent> <leader>q :xa!<cr>

  " Add some more complex mapppings
  let l:sid = matchstr(expand('<sfile>'), '\zs<SNR>\d\+_\ze.*$')
  execute 'nnoremap <silent> u :call ' . l:sid . 'undo()<cr>'

  " Set buffer options
  1wincmd w
  setlocal noswapfile
  setlocal nomodifiable
  3wincmd w
  setlocal noswapfile
  setlocal nomodifiable

  " Move to local window and to first conflict
  2wincmd w
  normal gg]]
endfunction

function! s:undo()
  if winnr() ==# 2
    normal! u
  else
    2wincmd w
    normal! u
    wincmd p
  endif
endfunction

Combined with settings for git and Mercurial, I find Vim is really good at solving merge conflicts.

#
# In .hgrc
#
[merge-tools]
vim.executable = gvim
vim.args = -f -d $local $output $other +MergeMode
vim.premerge = keep-merge3

#
# In .gitconfig
#
[merge]
  tool = mydiff
  conflictStyle = diff3

[mergetool]
  keepBackup = false
  prompt = false

[mergetool "mydiff"]
  cmd = gvim -f -d $LOCAL $MERGED $REMOTE -c "MergeMode"

First, I want to point out that the code snippet displays quite well my coding preference. I typically use two space indentation and I like to keep things in lower case. I use empty lines to separate blocks of code (then { and } make it easy to move between the blocks), and I try to write code that is easy to read - thus that don’t need too many comments. Still, I try to comment things that are difficult to understand.

The function s:setup_merge_mode() does most of the “magic”. First, it does nothing unless the diff option is enabled (i.e., we are diffing something). Next, and important(!): It assumes we are opening three files: The local file is buffer 1 (local = left), the remote file is buffer 3 (remote = right), and the merge result is buffer 2 (middle). The function basically just does two things: Creates some mappings and turns the local/left and remote/right buffers nomodifiable (and turns of swap files). I map ]] and [[ to move between conflicts (note that [n and n come from tpope’s unimpaired). Then I map do1 and do3 (or dol and dor) to diff obtain left|right, and dp to diff put. I use the last mapping only when I’m navigating one of the local or remote buffers. The mappings make it simple to go through the conflicts and choose which side to use. Finally, I use the s:undo mapped to u to allow undos to affect the merge result buffer, even when I am viewing the other buffers. Thus, if I do dp from the local buffer, I can undo it with u.

I have to stress: This snippet is specifically designed for my own workflow, and it needs to be used in a specific way. The function is used to define a command, and I’ve provided examples for how the command should be run in the .hgrc and .gitconfig files.

Kuniwak

Fri, 10 Jun 2016 00:00:00 +0000

Who are you and what do you use Vim for?

My name is Kuniwak. I’m a developer of Vint, that is a Vim script Lint.

I met Vim when I was a student of Tokyo National College of Technology, and I began maintaining Linux routers as a moderator of the Internet of the college dorm. But I didn’t know programming well (and also Vim, of course) because my course is electrical engineering. I learned these things there; three-phase AC, Faraday’s law, Lenz’s law, … So I knew only 3 things about Vim; how to open a file, how to switch modes and how to save and exit.

After 5 years, I began learning about programming in earnest, and I understood how important efficient editing is. Soon after this, I said, “Goodbye, my lovely cursor keys…” I decide to live with the HJKL keys. Then Vim locked me in its key bindings.

Now, I use Vim for Web development and writing technological books.

Introduce us to your Vim config.

I’m a Lint freak, so I love Syntastic. It is a plugin for syntax checkers (recently, Vint became one of builtin checkers of Syntastic). I have been checking my code by Syntastic for all languages I use.

And I also love the color scheme iceberg.vim. I can find syntax errors easily because this color scheme uses red for only warning colors.

One more thing. I have the self-introduction command :Kuniwak. My Vim can introduce me by displaying my profile:

I wrote the article How to Start “Vim as a Name card” (this article is written in Japanese). You can stop carrying your name cards if you read it, maybe.

What have been the most useful resources for you to learn Vim?

Lint rules.

Lint rules are made of many things should know such as the language history, pitfalls and so on.

For example, the lint rule “ProhibitEqualTildeOperator” is described in Google Vimscript Style Guide tell us about 2 important things. The first one is the following pitfall of comparative operators:

The matching behavior depends upon the user’s ignorecase and smartcase settings and on whether you compare them with the =~, =~#, or =~? family of operators.

We can avoid the pitfall in advance by only reading it.

The second one is the useful operators such as =~# or =~?. Newbies will use the bad operators like =~ and fall the pitfall if didn’t know the rule.

There are too many similar cases to list them all. So I think lint rules are very useful resource to learn language.

Tell us about your project vint.

Vint is a Vim script Language Lint.

You can know why Vint was born and what problems Vint can resolve by reading this slide.

The goal to reach for Vint is:

Highly extensible
Highly customizable
High performance

I think the most variable feature of lints is undefined variable detections. I have always been using this feature for most languages. Vint also support it, so you can find undefined variables.

For example, the variable param is not defined in the following code:

" /tmp/hoge.vim

function! DoSomething(param)
	echo param
endfunction

then, Vint can report the error by the command vint:

$ vint /tmp/hoge.vim
/tmp/hoge.vim:4:7: Undefined variable: param (see :help E738)

And the default output format is designed to be QuickFix-friendly, so you can use Vint with the cexpr command:

:cexpr system('vint ' . expand('%'))

And also, you can use Vint with Syntastic.

Most recently Vint began to support Neovim. I’m extremely grateful for the contribution (and other valiant contributions too).

Are you involved in a local Vim community?

Yes, I’m a staff of VimConf.

VimConf is an international Vim conference that have held in Tokyo in 2013, 2014 and 2015. In this conference, many Vimmers (inluding well-known contributors and plugin developers) spoke about their plugins or life-changing plugins or life hacking with Vim.

You can see slides and video records of the past VimConf:

Please contact us if you are interested in our conference!

Kassio Borges

Wed, 08 Jun 2016 00:00:00 +0000

Who are you and what do you use Vim for?

Hello there, I’m Kassio Borges. I’m a Brazilian Developer, currently working mainly with Ruby and Rails at Plataformatec. So I do use vim and neovim for coding, noting and draft ideas. I’ve been using vim for almost a decade, at the beginning I used it more for work on text files on servers, nowadays I use it for almost every text editing I have to do.

Introduce us to your Vim config.

First of all, I’d like to tell I care about my vim’s configurations a lot, however I also love to try new configurations, so my config files change a lot. My vim repo, on github, has more than a thousand commits, and it exists only for 4 years.

Some configs change a lot on my files: key mappings and plugins loading. I’m always trying new plugins, and also trying to live without some plugins. Today, I’m using 26 plugins on my configs, some of them only for neovim.

I have one config that I’d love to be default in vim, I use ! to search the current word/selection without move the cursor. This is awesome to look around where the current word/selection is being used, also to help with replacing. It’s very common for me to use :s//new-word/g just after a !. This way, before the replacement, I’ll see what’s changing on the file.

Besides that, there are some plugins that I use a lot:

CtrlP

I tried Unite.vim, fzf, and others, however CtrlP, for me, has the best UI in vim. It’s simple and fast enough with ag. Sometimes I’d like it to be faster, but for my current projects, it’s ok.
NERDTree

Sometimes I’m lazy enough to use my mouse. I know, I know… But sometimes I’m just reading code and don’t want to use the keyboard. NERDTree helps a lot with this, because, even in terminal, I just click, click, click and move around the code. Besides that, I like to have a tree view of the project from time to time.
Vim surround

This is the type of plugin that I think should be default on vim. I don’t know when I use, but everytime I try to live without it I can’t. Vim without surround, for coding, it’s to painful for me.
Vim repeat

This is another example of a plugin that should be default, I don’t recall to use, or when it’s possible to use or not, I just use. And I tried remove it, but, again, my coding day it’s too painful without it.
ultisnips

I’m lazy, snips helps me a lot. And this was my chose, I don’t recall the reason. I tried others, but this one fitted better to my use.
Vim Session Manager

This is a little plugin I created to help me when I want to restart vim without loose my current window setup. I just run <leader>ss to save a session, <leader>sl to load and <leader>sd to delete. The plugin manages the session name and folder for me.
Neomake

As a coder, for me is awesome run the linter all the time I save a file, and Neomake, with neovim, works like a charm for that.
Neoterm

Again, as a coder, and a lazy one, I like to run tests, or little terminal jobs fast and without leave the editor. So I created this to wrapper the :terminal feature of neoterm and run tests, or use a REPL, os just send a command without much effort.
Syntax plugins

From my 26 plugins, 9 are language syntaxes. Ruby, Rspec, Minitest, HTML, Javascript, Elixir, Markdown and Tomdoc.

I tried a lot of statusline plugins, but I didn’t like anyone so I use a fancy statusline that I configured by myself.

Currently I’m using ocean-next colors, on iTerm2 an neovim/vim. It’s very nice on neovim with $NVIM_TUI_ENABLE_TRUE_COLOR enabled.

I already used as leader key \ and ,, but nowadays I’m using <space>. It makes a lot of sense for me to use the biggest key on the keyboard as the leader one.

Some people already asked my about how to organize vim configs. I like to organize my configs as personal plugins. I have on my vimrc/init.vim only sets and some little vim boot configs. All external plugins’s configurations are on my /plugins folder. All my custom functions are in /autoload. This made my setup easier to maintain and faster to load, because vim doesn’t load my functions on boot.

What have been the most useful resources for you to learn Vim?

I read almost all :help. I learned a lot reading the source code from the plugins I use most, like vim-ruby. Vim-casts and Pratical Vim are also a good place to learn how to improve the vim skills. I love learn more about regexp and replace techniques, because refactoring large code bases are hard and this can help a lot. Also, I like to learn about all the news, so I try to follow every new feature/concept on vim/neovim.

What’s the most recent thing you’ve learned about Vim?

I fell in love with vim few years ago, but it was missing some features. Neovim brought some of the missing to the table. I just learned that vim 8.0 is back to the track, bringing channels and a native plugin manager and I’m really excited about these new features.

How did you get started writing Vim plugins?

I guess my first plugin as the vim-session_manager. Writing plugin, for me, it’s not a vim thing, I’m always trying to get all I can from my tools. With vim, one way to do this is writing plugins. After writing vim-session_manager, I was more comfortable with vim script, so I started write a lot of custom functions, and other little plugins.

Tell us the story behind your plugin neoterm.

Before neovim I used to use vim+tmux. I had a plugin to send commands to tmux. But I wasn’t satisfied with that. I’d like something more IDEish. So when neovim brought :terminal to the table I saw the opportunity to run tests and other commands without leave vim, and that was awesome. I’m currently without many time to work on neoterm, but I’d like to improve its tests’ statusline feedback. Today it’s done by pattern match, I’d like to improve it to use the test command status instead, this way we’d have a more reliable test status on neovim’s statusline.

Are you involved in a local Vim community?

I went, recently, to the first vim meetup on São Paulo and talked about neovim and vim configurations organization. I really enjoy help people to use better vim/neovim, and I intend to do this again when possible.

function! preserve#preserve(command)
  setlocal lazyredraw
  let l:search=@/

  let last_view = winsaveview()
  execute a:command
  call winrestview(last_view)

  let @/=l:search
  redraw
  setlocal nolazyredraw
endfunction

This is a snippet that I copied the idea from I don’t know where (I think is vim wiki). I use this function on many keymappings, and other functions. What it does is very simple, it runs the given command without move the cursor or the current window view. I use this, for instance, in the ! mapping that I mentioned before.

Daniel Schauenberg

Sun, 05 Jun 2016 00:00:00 +0000

Who are you and what do you use Vim for?

My name is Daniel and I’m a staff engineer at Etsy on the DevTools team. We are an infrastructure team that handles things like maintaining the deployment system and the development environment, the application level metrics stack, and dev data access. My daily work is a very fun mix of software engineering and operations type work.

Due to the nature of that I write a lot of Chef, shell scripts, ruby, and PHP. Outside of work I also write the occasional bit of Go or C++ for some of my open source projects. For all of this I always use vim, 99% of the time running inside a tmux session.

I got introduced to vim in 2004 by a friend who showed me around Linux and UNIX when we were both first semester university students. Back then I didn’t have a preferred editor and as I learned more about Linux I just used vim as it already was installed on most systems. I very quickly switched from Linux to FreeBSD and with that from vim to vi (or nvi rather) as the default installed editor. At that point I hadn’t really started using any plugins, so going from vanilla vim to vi wasn’t really a big deal for me. I used it long enough in that setup that when I got my first Mac and started using editors like SubEthaEdit, Textmate, and Smultron because I liked their native look and feel, I had already built up the vim muscle memory. And as I was using gVim on the Windows machines at work, I kept the muscle memory although I wasn’t using vim on my personal machines. When I went back to grad school I eventually switched to MacVim. Mostly because Textmate and all the other OS X editors seemed like abandon ware at the time. And I wanted something I was familiar with and I knew would stick around. So I decided to go back to vim and go full in with customizing it to my needs. And now roughly 7 years later vim is basically the only way I edit text files on a computer. I use it for code, blogging, journaling, meeting notes, emails (via mutt), and accounting (via ledger). I try to use as much of vanilla vim as possible as my job includes working on a bunch of different servers and I don’t want to be slowed down too much when I don’t have my vim config ready. I also try to only use plugins that are purely written in VimL. That way I don’t have to deal with how to build the right vim on the different platforms (OS X, Linux, FreeBSD) I’m most likely to use it on.

Sadly on the iPhone vim is not a super great choice so I use Editorial there, mostly for writing blog posts when I don’t want to have a laptop open.

Introduce us to your Vim config.

When I went back to vim I also started using plugins for real. While writing my undergrad thesis (with vim and latex) I had already started with a super simple vimrc file I found somewhere and that is still the base of the setup I use today - 9 years later. When I started adding plugins to my vim setup, some of the first ones I added were pathogen and fugitive. I also was used to having tab complete things so I installed supertab. From there I constantly added and removed some plugins and over the years I’ve converged to a dozen or so plugins that I have installed. I keep them together with my vimrc in a git repo on GitHub and I wrote a Makefile that handles installing the configuration via symlinks and updating and adding plugins via a vim-bundle script I found somewhere and have downloaded into my ~/bin. The plugins I use most are the ones that are just enabled in the background and do their thing, like syntastic, supertab, tabline, or syntax highlighters. I do have some others to add functionality, like ctrl-p, nerdtree, or VoOM. I do use them occasionally, but most of the time forget about them. A plugin that falls into that category but that I use a lot is vim-zenroom2. It creates a writeroom style focus in vim and I love it for writing. I use it a lot for blog posts, journaling, meeting notes, or documentation writing.

Another plugin I wrote and use a lot is vim-stencil. It provides a simple way to have templates for vim that you can load into a buffer. It’s inspired by the vim skeleton files and I use it a ton for meeting note templates, journaling scaffold and weekly planning notes. A nice side effect of writing emails in mutt is that I can also use it for canned responses. Plus I can keep all of my templates in git together with my vim config. The plugin also provides a very basic set of variable expansions for common things like date or weekday.

I use solarized light as my theme although I wasn’t a big fan when it came out. I used a slightly patched version of molokai for many years. But one day I realized that I was really annoyed by the different applications I use a lot in the terminal (regular terminal colors, vim, mut, weechat) all look different. And I wanted consistency and at the same time switch to a light theme as it was easier on my eyes. And solarized light was the only one people had already ported to most applications. So I gave it a real shot and now I really enjoy it.

Some of the maybe more interesting things in my vimrc is that I have line numbers turned off. I used them for a long time, then played with relative line numbers for a bit and then decided that I don’t really care about it most of the time, so I just turned it off. When I really want the current line number I just look in the statusline. I also have a lot of one off settings and inline functions in my vimrc. I have a Today() function that inserts the current date in a specific format and is mapped to ,d (, is my leader key). I use it a ton when writing my work journal or taking notes in meetings. I’ve also inlined the GoFormat function from the deprecated official plugin. They made vim-go the new official one and it did way too many things for my taste as I only really wanted automatic formatting for my Go code.

I also activate spelling for a certain set of file types. Funnily I still have it enabled for .tex files from my university days. But these days the setting to enable it for markdown and mail (as I use mutt) is what I really use. As those types of things are mostly read by others (email and documentation) and written in English which isn’t my first language.

Speaking of writing in vim. I use it a ton for non programming as well. And as mentioned I use vim-zenroom for focused writing which depends on Goyo. In order to make the experience better there I have some Goyo hooks in my vimrc to close the buffer if it’s the last one in Goyo mode and also run a command to disable the tmux status bar for complete focus.

I also have the arrow keys disabled to force me to use hjkl for navigation. I did that when I started at Etsy and knew I would be working in vim a lot more so I decided to train that muscle memory. A side effect of that is that I enable hjkl navigation support wherever possible in other apps.

What have been the most useful resources for you to learn Vim?

I think the most helpful resources have been the vim wikia and random blog posts when I was researching some specific things like setups for writing or programming in specific languages.

When it comes to writing plugins, I think I learned the most from reading @tpope’s and @mattn’s code on GitHub.

What’s the most recent thing you’ve learned about Vim?

I can’t remember what the most recent thing is, but something I want to learn is how to better navigate within text. I do use G, ctrl-d, and ctrl-u a lot for longer jumps. And I use O/o and A/a and those commands a lot when I know I want to insert things. However within textblocks or when in visual mode I still hold down hjkl until the cursor is where I want it to be. I would love to have a more ingrained understanding of how to jump more efficiently in vim.

How did you get started writing Vim plugins?

I think my first steps in plugin writing must have been around 2010 when I was trying to add mustache support to the zencoding vim plugin. I was just learning about the current state of web development and tried out a lot of things. I was really into mustache and the idea of writing HTML faster with zencoding intrigued me. I think I never actually got it working or I sent a pull request and it didn’t get merged and I failed to follow up. But it was super fun and I learned a lot.

Tell us about your plugin simplenote.vim.

simplenote.vim is a plugin that lets you edit and manage your simplenote notes right from vim. It really grew out of the situation that I was a big fan of simplenote and it was the only application I used for writing outside of vim. So I wanted to see if I couldn’t get it working as a vim plugin and not have to got the route via Dropbox syncing. It was really mostly a curiosity thing and something I thought would be cool to exist. My initial plan was to write it completely in vim script. As I me tokens before I really like having a vim setup that doesn’t need any special things compiled in. And I had a rough version working that used curl for talking to the API and presented JSON to edit. However when it came to JSON parsing all the existing solutions were not super intuitive and I needed to somehow make it easy to install the dependencies for the plugin as I wanted it to be really easy to use. And then I would still have to write all the API wrapper methods for the actual API. So I decided to just write a python module for the simplenote API and publish that as well. And make a strict separation between data access and storage which would be Python and vim interfacing which would be vim script. I chose Python at the time because I was already familiar with it and had written a bunch of API wrappers for different things in it already.

The first version was super barebones and pretty rough, but it was incredibly fun to write it. The hardest part was probably testing it as I had no idea how to write unit tests for the vim script part of the plugin. So it was a lot of editing, putting in echo statements, and opening another vim session to try it out. I learned a ton about vim’s buffer and window model, how to run concurrent Python inside my editor and how to manage a somewhat popular open source project.

After a couple of years of using it I stopped as I didn’t want to host my (at times pretty personal) notes on someone else’s computer. And as I couldn’t give the project the attention it deserved while not actively using it I reached out to @atomicules who had been the most active outside contributor at that point and asked him if he wanted to take over maintenance of the vim plugin and the Python module. Fortunately he was up for it and so for the last 3 years he has been doing a fantastic job of maintaining and pushing the project forward.

Are you involved in a local Vim community?

I’m not. For some reason that has never occurred to me.

function! Today()
  let today = strftime("%A %m\/%d\/%Y")
  exe "normal a". today
endfunction
command! Today :call Today()

This is the snippet I talked about earlier that inserts the current date after the cursor position. It’s pretty simple and yet incredibly useful for me. It creates a string from the current date formatted as “weekday day/month/year” and appends it at the current position. The function is then mapped to a command with the same name so I can call it as :Today and also map that command to a leader key combo.

What have you been working on recently in Vim?

I’m currently working on a bunch of infrastructure projects at work that mostly involve writing chef recipes or PHP. I also constantly use vim to update documentation and write emails.

Gabriel Berke Williams

Wed, 04 May 2016 00:00:00 +0000

Who are you and what do you use Vim for?

My name is Gabriel Berke-Williams and I am a developer at thoughtbot.

I started using Vim years and years ago, but didn’t read the :help enough and started using Textmate instead because I thought it had more features. Once I got to thoughtbot, I was surrounded by really great Vimmers and I switched back to Vim. I use Vim write all of my code (Ruby, and increasingly Haskell) and all of my blog posts. Sometimes I even use it to write long pull request comments. I love Vim because I can move almost faster than I can think. Typing anywhere except Vim feels slow without the modal bindings.

I use the latest Vim version available in Homebrew (currently 7.4.x), and I check for updates every few days. I use terminal vim because all of my workflow is terminal based, and a graphical editor like gvim would break that flow.

Introduce us to your Vim config.

I’ve spent a lot of time – probably too much time! – on my Vim config, and I’m adding bits and pieces constantly. It’s all public in my dotfiles repo. I’ve tried to make it visitor-friendly, with lots of comments and documentation. (Check it out and open an issue!)

My Vim configuration is very split up. It’s a little complex, so if you’re confused, or would like some help improving your own Vim configuration, let me know on Twitter.

I use rcm, which is a tool that symlinks files from a separate dotfiles directory (say, ~/.dotfiles) directly into your home directory. Any non-dot file or directory under the dotfiles directory will be installed as a dotfile. For example, .dotfiles/zshrc will be installed into ~/.zshrc.

rcm lets me split up my dotfiles into different tags, so I can have separate directories for tmux settings, git settings, etc. Each tool has its own extra Vim settings – if someone wants to use my dotfiles but doesn’t use tmux, then they can easily exclude tmux-specific Vim configuration with rcm since it’s in its own directory. I like being able to point people to specific settings, e.g. for tmux or Haskell.

Here’s a simplified diagram of my ~/.dotfiles directory, which rcm links into ~/.vim, ~/.zshrc, etc:

vim
├── ftdetect
│   └── markdown.vim
├── ftplugin
│   └── gitcommit.vim
├── options.vim
├── plugins.vim
├── rcplugins
│   └── ctrlp.vim
tag-tmux
└── vim
    ├── ftdetect
    │   └── tmux.vim
    ├── plugins
    │   └── tmux.vim
    ├── rcplugins
    │   └── vim-tmux-runner.vim
    └── tmux.vim

The rcplugins folder holds plugin-specific configuration, like ctrlp.vim-specific settings.

All of my Vim settings go in the vim/ directory. I have my “main” plugins in vim/plugins.vim, and tool-specific plugins in tag-PLUGIN_NAME/vim/plugins/PLUGIN_NAME.vim. That way people who don’t use a given tool (like tmux) don’t pull in tmux-specific Vim plugins. It also makes it easier for me to give advice to people who are setting up tmux (or whatever) for the first time, because all the plugins are in the same place.

You can see that the tag-tmux/vim structure mimics the vim/ structure – that’s because rcm will copy them both into the ~/.vim directory together, so the separation is invisible to Vim. That’s a little hard to visualize, so here’s the (simplified) output of tree ~/.vim, assuming the same structure as above:

~/.vim
├── autocommand.vim -> /Users/gabe/.dotfiles/vim/autocommand.vim
├── autoload
│   └── plug.vim -> /Users/gabe/.dotfiles/vim/autoload/plug.vim
├── ftdetect
│   ├── markdown.vim -> /Users/gabe/.dotfiles/vim/ftdetect/markdown.vim
│   └── tmux.vim -> /Users/gabe/.dotfiles/tag-tmux/vim/ftdetect/tmux.vim
├── ftplugin
│   └── gitcommit.vim -> /Users/gabe/.dotfiles/vim/ftplugin/gitcommit.vim
├── options.vim -> /Users/gabe/.dotfiles/vim/options.vim
├── plugins
│   └── tmux.vim -> /Users/gabe/.dotfiles/tag-tmux/vim/plugins/tmux.vim
├── plugins.vim -> /Users/gabe/.dotfiles/vim/plugins.vim
├── rcplugins
│   ├── ctrlp.vim -> /Users/gabe/.dotfiles/vim/rcplugins/ctrlp.vim
│   └── vim-tmux-runner.vim -> /Users/gabe/.dotfiles/tag-tmux/vim/rcplugins/vim-tmux-runner.vim
└── tmux.vim -> /Users/gabe/.dotfiles/tag-tmux/vim/tmux.vim

This structure lets me split up my configuration but still have it all in one place at the end for Vim to read.

Here are my base options:

set showcmd
set smarttab
set cursorline
set ignorecase
set incsearch
set smartcase
set relativenumber
set number
set autowrite
" Set leader to <Space>
set leader=" "

My leader is Space because it’s a big key that’s easy to hit, and I can type it with either hand.

And here are some options I like that are less common:

" When the type of shell script is /bin/sh, assume a POSIX-compatible shell for
" syntax highlighting purposes.
" More on why: https://github.com/thoughtbot/dotfiles/pull/471
let g:is_posix = 1

" Open below and to the right, the same way you read a page
set splitbelow splitright

My most-surprising option is definitely set scrolloff=999. It keeps the cursor in the middle of the page while the text moves around it. I like it because it makes it easier to track where the cursor is. (Though it’s made some people a little dizzy when pairing!)

I use a lot of plugins, which I manage with junegunn’s excellent vim-plug. I used to use Vundle, but vim-plug is much more actively maintained and has support for parallel installation. My favorite plugins are all from Tim Pope and my coworker Chris Toomey:

christoomey/vim-tmux-runner sends commands from Vim to tmux
christoomey/vim-system-copy lets me use the system clipboard just as easily as I do the Vim clipboard

I have a bunch of Ruby/Rails plugins, including vim-ruby, vim-rails, vim-rake (which is vim-rails, but for Ruby projects) and vim-spec-runner, which I wrote with Chris Toomey, which I use for running RSpec tests. It works really nicely with vim-tmux-runner.

I use ctrlp.vim for fuzzy finding. I’ve configured it to use ag under the hood, which is so fast that I don’t even need to cache:

let g:ctrlp_user_command = 'ag %s -l --hidden --nocolor -g ""'
let g:ctrlp_use_caching = 0

One holdover from my Textmate days is that I use <Leader>t to trigger ctrlp.vim, to mimic Cmd-t:

let g:ctrlp_map = '<Leader>t'

Here are some non-language-specific plugins I can’t live without:

lightline.vim, a fancy statusline
vim-trimmer, to remove trailing whitespace on write
ag.vim, for searching
vim-easydir, which auto-creates parent directories when I write a file that’s in a nonexistent directory
jellybeans.vim, my One True Colorscheme (I pair it with the Tomorrow Night Eighties terminal theme).
vim-emoji, so I can put emoji in my statusline, because I like seeing emoji all the time. (OK, maybe I could live without this one.)

What have been the most useful resources for you to learn Vim?

My coworkers Chris Toomey and Gordon Fontenot are Vim tinkerers like me, so we watch each other’s dotfiles on GitHub, comment on neat stuff, and copy what looks cool. All three of us have a lot of code with comments like “Thanks Gordon!” or “Stolen wholesale from christoomey”. Pairing with other people has been the best way for me to learn Vim. At some point during the pairing they’ll do something cool and I’ll ask about it, which always leads to me learning something new. Steve Losh’s Learn Vimscript the Hard Way was invaluable when I decided to write my first Vim plugin.

What’s the most recent thing you’ve learned about Vim?

I learned that there’s an autocommand for when Vim is resized. It’s really helpful because it gets triggered whenever I open a tmux split next to Vim. I use it to resize all of the Vim splits when Vim is resized:

autocmd VimResized * wincmd =

Chris Toomey also reminded me how great custom text objects and “verbs” are, and introduced me to some new ones. The most useful one recently is vim-textobj-entire, which when combined with Chris’s vim-system-copy plugin lets me do cpae to copy an entire file to the system clipboard for pasting in other places.

How did you get started writing Vim plugins?

I’d been using Vim for a while and wanted to get to know my editor more. I read Learn Vimscript the Hard Way, played around with it, then paired with Chris Toomey to write vim-spec-runner. We wrote vim-spec-runner for a couple of reasons:

Existing spec runners didn’t integrate well with arbitrary command runners (e.g. you couldn’t configure them to send commands to tmux)
I wanted to learn how to write a “real” Vim plugin

After that I felt confident enough to write vim-rdio, which is a totally absurd plugin that uses Vim to run AppleScript to send commands to an Rdio tab in Chrome or Firefox. It was a neat technical challenge (I wrote about it) and worked well, until Rdio tragically shut down.

Josh Branchaud

Mon, 02 May 2016 00:00:00 +0000

Who are you and what do you use Vim for?

I am a software developer at Hashrocket, a web development consultancy. We primarily do Ruby on Rails development, but this generally involves heavy use of JavaScript and PostgreSQL. Everyone I work with at Hashrocket uses Vim. There are a common set of plugins and configurations that we have installed across all machines. We pair 100% of the time, so having a consistent Vim setup makes it easy to transition between computers and projects.

I use Vim extensively outside of professional work. Not only do I use it when working on side software projects, but also for just about any kind of writing. I write daily posts in my TIL repository about using Vim. I even put together a project-specific vimrc file to give myself a custom utility function just for that project. I also blog with markdown files in Vim. I recently discovered that the vim-markdown plugin supports syntax highlighting of fenced code blocks, so that is a game changer.

I’ve been using Vim since college, so for about 6 or 7 years. It has only been in about the last 2 years though that I’ve really felt like I’ve had any mastery of Vim. I used to do a lot of Java development in college and it didn’t make a lot of sense to do that outside of any IDE (like Eclipse), so I used Vim less frequently then than I do now.

I like to use Vim in the terminal with the Macvim binary. I almost exclusively use a Mac and while the system Vim is fine, the Macvim binary provides tighter integration with OS X. This means that I can copy stuff from another program into Vim with p and likewise I can yank text from Vim for use in another program. I sometimes use Atom and Sublime (with Vim-mode enabled), but I usually end up getting frustrated when I start hitting the bindings for my favorite plugins and they aren’t there.

Introduce us to your Vim config.

A long time ago I wanted to step up my Vim game, but I didn’t really understand how to tailor/configure Vim to my needs. I ended up copying a fellow developer’s vimrc file, which was heavily customized. As I’ve came to understand those settings and develop my own opinions, I’ve began to tweak things here and there. In the last couple years, I’ve started to cull back some of the customizations. Many of them were there but I wasn’t even using them.

I’ve heard people say, “Don’t put anything in your Vim configuration that you don’t understand.” I mostly agree with that. However, the defaults for Vim are not great for extended use. People just getting started with Vim are going to experience a lot of friction with the defaults. Learning to use Vim and configure it at the same time is a daunting task. For this reason, I really like sensible.vim. It makes Vim behave in a sane way without over-customizing it.

What I’m getting at is that I’m not too picky about any particular vimrc settings as long as the stuff you find in sensible.vim is turned on and I have my plugins (see below).

One line in my vimrc that I really like having around for everyday development, but don’t see very often is:

runtime! ftplugin/man.vim

This enables a built-in plugin that opens man pages in a Vim split window by using the :Man command (e.g. :Man vim).

Some of my favorite plugins are the ones that can be used in just about any context. The three that come to mind are:

surround.vim - I take advantage of this plugin in just about any language and even in just markdown files (I use parenthesis a lot) because it is so flexible and powerful.
eunuch.vim - I like not having to leave Vim to do quick one-off tasks like remove and renaming files. Sure I can shell out, but this plugin makes those things even easier.
bufexplorer - This plugin makes it easy to quick jump between a handful of buffers when I get into a development cycle. I use this plugin almost exclusively for the <leader>bs feature.

Additionally, I use rails.vim and fugitive.vim a ton at work. These two plugins alone allow us to achieve a really tight, efficient development cycle when working on Rails applications.

I use many more plugins, but these are the ones I’d have a hard time living without.

I don’t get to caught up in a particular color scheme as long as the different syntax elements are clear. I do, however, prefer a black background. My current color scheme seems to be railscasts.

My leader key is backslash (\). I don’t tend to use many leader mappings, but there are a couple that I’ve been experimenting with recently.

I have mapped \d to quickly open the parent directory of the current file with netrw.

nmap <leader>d :e %:h<cr>

I also have \D to quickly create any directories for the current file path.

nmap <leader>D :!mkdir -p %:h<cr>

Although, I’ve been using this less and less since discovering eunuch.vim’s :Mkdir! command.

What have been the most useful resources for you to learn Vim?

I mentioned earlier that despite having been using Vim for the past 6 or 7 years, it was only in the last couple years that I’ve really started to feel like I’ve mastered it. The reason for this is because I am just now discovering the best resources for learning Vim.

First and foremost, I learn an incredible amount my pair programming everyday in Vim. All my coworkers at Hashrocket combine to be a wealth of Vim knowledge. Every time I switch pairs I learn a handful of new things and more efficient workflows.
I’ve started to effectively use the Vim help files. There is so much information in those files. Sometimes I will be looking up one command and 15 minutes later I will be halfway down the help file reading about all these Vim features I had no idea about.
Drew Neil’s Practical Vim is another really valuable resource. I only recently read it. I wish I would have discovered it years ago.

I recently wrote a blog posted titled “How to get help with Vim” which is a big part of this.

What’s the most recent thing you’ve learned about Vim?

I recently learned about the gn motion for interacting with matches to a search pattern. I’ve yet to use it much, but I can see how it is a great complement to doing standard substitutions.

What I love about Vim is the composability aspect. In learning one simple motion, I’ve actually learned a bunch of different ways to interact with and manipulate a piece of the buffer.

Are you involved in a local Vim community?

I help organize VimChi, Chicago’s Vim Meetup. We meet once a month and we either invite a single speaker to talk about something they are interested in or we do lightning talks. Any Vim users in the Chicago area should definitely check it out.

I’ve given talks about how I use buffers in Vim and how sensible.vim works.

It’s not much, but I added this small snippet of vimscript to my TIL repository to make it easier to get a count of the TILs:

function! CountTILs()
    execute '%s/^- \[//n'
endfunction

nnoremap <leader>c :call CountTILs()<cr>

It is a fairly standard substitution command, except for the n on the end. With the n there, instead of doing a substitution, this returns a count of the number of matches for the given pattern. I feel like this is a little known feature of the substitution command. It’s pretty handy though.

What have you been working on recently in Vim?

I am constantly exploring new languages. It is always interesting to see what sorts of tooling different communities have wrapped into Vim plugins.

For instance, I do Clojure development in Vim from time to time. While many people might recommend using Emacs for a lisp-style language, there is actually some pretty good tooling for Vim. There is a plugin (fireplace.vim) that connects to a Clojure REPL so that you can execute snippets of code from within Vim. Another plugin (vim-sexp-mappings-for-regular-people) provides some handy mappings for manipulating Clojure code.

Artur Shaikhullin

Thu, 14 Apr 2016 00:00:00 +0000

Who are you and what do you use Vim for?

I am a software developer, working in a private company engaged in reception of payments and payment services. On this job, I have a wide range of technical duties. Begin with configuration of the servers, ending with the modification of the payment system code.

Perhaps not surprisingly, I use vim in the work, because it is always in my hand. And what is most remarkable is the fact that the entire stack development and support I produce in vim.

At work I write in such languages as java, c++, python, javascript, bash.

I am a big fan of free and open source software.

I have been using Linux as the primary operating system about 8 years, and with vim I met almost immediately, although the first meeting was in the spirit of “wtf… how to get out of here?!”. But frequent configuration server via the command line become to the fact that I learned basic commands. So I use vim for about 6 years. But work with it closely I began 2 years ago.

I use vim for all my daily tasks. I have not had to choose from other similar editors, historically, as I said, I started using vim forced. In addition to vim I use a lot of console applications with vi-like navigation method. Therefore, I have no need for a GUI text editor. In the war of Vim vs. Emacs, the winner became vim :).

Working closely with this editor made me vim addicted. Now keys of most applications that I use, have similar combinations as vim. I use a tiled window manager - bspwm, mutt as the mailer, weechat with vi-mode plugin as a messenger, elinks for fast surfing and qutebrowser for javascript heavy sites and etc. In the terminal, I always run tmux, and zsh operates in vi mode. Many applications do not have ability to setup vi like hotkeys, so I did a system wide vi mode, in this mode hjkl converted to the arrow keys. In my dotfiles I accumulate configurations for applications used by me. I use console vim 7.4.

Introduce us to your Vim config.

I try not to change my configuration frequently. Reading the blogs or watching screencasts and bumping into interesting solution, I try them, sometimes keeping. One of the latest: nnoremap g= gg=Gg`` corrects the indentation of all file from any position.

I often use third-party extensions, I have about 60 plugins. Sometimes I check the list and remove plugins that I do not use. I think now is the time to do it :).

One of the most popular and actively used is vim-easymotions. My space key triggers the plugin and I can jump fastly wherever I need, workflow is super cool, sometimes I want to use it in other applications which has vi mode.

To navigate through the file system I use vifm, and plugin vifm.vim. I like to use this file manager, because it looks like a continuation of my editor, there I can use commands such delete, yank, and navigation as well as in vim and, while having a great set of features. The work is a more holistic.

I also like to use startify. It gives joy to my editor and makes it easier to continue editing the files.

Certainly, unite. This is probably the most commonly used plugin. Search files, navigate buffers, menu design, etc. For example, for my main project, I created a menu with commands to run maven, I can now quickly choose from menu to compile the application, start the server, do deploy applications, run test, etc.

For completion I use YCM, in general, I happy with it, it works well with C++ projects, and in my case with Qt.

As a manager of plugins I use NeoBundle.

Of course, I changed my leader to , but to be honest I do not really like to use it. Also I reversed ; and ‘:’, I often use the command line, and this change is unloaded my little finger.

My color palette is adjusted by my terminal (urxvt), in which I use two colorschemes based on my desktop wallpaper colors - dark and light one. Vim colorscheme in this case, only configuring colors for different elements of the text using system’s 16 colors.

I do not use plug-ins for the statusline. It’s pretty simple, I found it configuration in some blog. In the beginning, I added vim logo, using powerline patched font, below the cursor position in the line, file name, file status, dev branch, file format, and the current position in the file.

What have been the most useful resources for you to learn Vim?

My first serious resource was A Byte Of Vim. Most of the information I got from there. Then, various blog posts, screencasts, now from time to time I’m reading Practical Vim. To deal with VimScript I read Learn Vimscript the Hard Way. And of course :help.

What’s the most recent thing you’ve learned about Vim?

I just figured out that zz move screen line to the middle. And why I did not know this before.

How did you get started writing Vim plugins?

The first plugin I started writing out of despair. When I did not want to run java IDE, to make small changes in the project, but would like to have at least the minimum operating completion. I had to fix errors in the original plugin vim-javacomplete, that was stopping to work time to time. When such corrections have accumulated quite a lot, I have decided to release an updated plug-in.

Java often requires to be verbose, so the code generation in the IDE keeps many from switching to vim.

As soon as I switched completely to develop java applications in vim, of course, I wanted to have more features. Such as code generation and simple refactoring. I will continue to work on functionality, as I will have free time. Also in the plans to revise the documentation, there is now a mess, in which hard to navigate. Work on the plug-in stability also priorities.

The main inspiration of vimscript code is probably given by the author of the original plugin vim-javacomplete. As well as mattn, and other experienced VimScript developers who have done a lot of useful PR, after the publication of the plugin.

Are you involved in a local Vim community?

Honestly, I am not sure that such communities exist here.

I often use renaming the word under the cursor around the file:

nnoremap <Leader>s :%s/\<<C-r><C-w>\>/<C-r><C-w>/g<Left><Left>

My unite menu for maven execution:

    let g:unite_source_menu_menus.mvnee = {
        \ 'description' : 'Maven project with glassfish',
        \}
    let g:unite_source_menu_menus.mvnee.command_candidates = [
        \[' mvn clean', 'make clean'],
        \[' mvn compile', 'make compile'],
        \[' mvn package', 'make package'],
        \[' mvn clean package', 'make clean package'],
        \[' mvn deploy', 'make -pl project-ear asadmin:deploy'],
        \[' mvn undeploy', 'make -pl project-ear asadmin:undeploy'],
        \[' mvn restart-domain', 'make -pl project-ear asadmin:restart-domain'],
        \[' mvn stop-domain', 'make -pl project-ear asadmin:stop-domain'],
        \[' mvn test', 'make test'],
        \]
    nnoremap <silent> <space>m :Unite -direction=botright -silent -buffer-name=mvnee menu:mvnee<CR>

What have you been working on recently in Vim?

I try to do everything in vim. Development, writing an email, writing this text. As almost all the system functions I perform with the same keys combinations as in vim, it fairly easy to switch between tasks. And all the work is a single hands’ flight over the keys of the keyboard. It is the most important advantage of my switch to vim for the development. And it is fast enough to run.

Andre Torrez

Tue, 22 Mar 2016 00:00:00 +0000

Who are you and what do you use Vim for?

I’m a software developer who lives and works in San Francisco. I work at Slack and before that I had a bunch of projects that I don’t work on any more.

I use Vim solely for writing code. I’ve tried using it for writing blog posts or note taking but I think it’s uncomfortable for that and so I stopped. I will say I’m a Vim novice and I probably learn something new every week, so maybe I’ll rethink the code-only rule when I get better.

I first used Vim like most people: in a panic because ctrl-c did nothing and my only resort was backgrounding the job and killing it. This was in the mid-90s while tinkering with Linux. Over the years my usage of Linux grew but Vim was always something I had to use because it was the only text editor that was always available. I could :wq and u plus a few other things and that was good enough for conf files.

A few of years ago, while getting by with my ci" and dd, I found myself administering a bunch of Linux machines and I decided to finally figure out what the heck I was doing with Vim. I knew what ci" did, but I couldn’t tell you why. So I went all in: full-screen on my Mac, deleted SublimeText, installed Janus, NERDtree, a bunch of themes, a bunch of snippets from other people’s .vimrc files, and anything else I could get my hands on.

It was a disaster! I wasn’t learning Vim at all. I was learning how to use all the add-ons and configurations from people who had been using Vim for a while thought they might like. I had no idea what I actually needed.

So I started over with an empty .vimrc and have slowly (very slowly) added lines as needed. And the funny thing is the longer I use Vim the more I realize I don’t need very many lines at all.

My work computer is a Chromebook Pixel. I run a chroot with a headless Ubuntu (Trusty) inside of it and therefore whatever version of Vim that installs when you run apt-get is what I use. I switched to this setup after many years of trying to replicate production environments (Linux/Ubuntu) with development computers (Mac OS X). I was tired of the gymnastics required to build certain libraries when on my Linux servers they just worked.

Being able to get my work done using Vim made it that much easier to switch. I didn’t really consider it until I answered this question but I never would have been able to switch to the Chromebook had I not spent a year getting competent with Vim.

Introduce us to your Vim config.

It’s 17 lines! I’m just going to comment on the sections:

execute pathogen#infect()

For ctrlp, vim-gitgutter, and vim-surround, but I often forget I even have vim-surround. I should probably use it more.

syntax on
filetype plugin indent on

I write a lot of PHP and Python and the two styles could not be more different.

set list
set lcs=tab:\|-,trail:-

I adored the invisible character view in SublimeText and I tried to replicate it. It’s not nearly as nice.

set autoindent
set tags=tags;
set hlsearch
set incsearch
set ruler
set number

Some standard stuff here. ctags are my life.

nnoremap <C-J> <C-W><C-J>
nnoremap <C-K> <C-W><C-K>
nnoremap <C-L> <C-W><C-L>
nnoremap <C-H> <C-W><C-H>

I swiped this from someplace when I was into splits. They’re shortcuts for switching focus. I use tabs now, but occasionally I will need these for a file split or :help.

set runtimepath^=~/.vim/bundle/ctrlp.vim
set shell=/bin/bash

Bundle settings. The second line is because I use Fish shell and vim-gitgutter won’t work with it so I have to override my shell in Vim.

I know this is a pretty sparse .vimrc. I keep it in a private repo now with my Fish shell config so I can drop it onto any system I plan on using a lot. The nice thing about my config is that if I do find myself on a vanilla install of Vim I don’t feel like I’m missing too much.

I don’t think this config has changed significantly in over six months. I keep meaning to set up ctrlp to use ag (Silver Searcher) and I might do that now that I just Googled how to do it. But otherwise I’m pretty happy with this setup.

You’ll probably notice I don’t even have a colorscheme! I used to use Solarized dark on my Mac but I like the default ChromeOS color scheme so much I didn’t even bother changing it when I got the Pixel.

What have been the most useful resources for you to learn Vim?

I read Practical Vim by Drew Neil in a day when I rebooted my .vimrc. Now I just use :help whenever I get in a jam. Or I Google something that sounds like the thing I want to do and read from there. I probably end up on vi.stackexchange.com at least once a day. I think I could just use :help but sometimes I have to describe what I want to do and let Google point the way.

What’s the most recent thing you’ve learned about Vim?

Registers! I never paid attention to them because it felt so awkward typing that many keys to save something. When I used to work on a Mac I’d rely on a clipboard manager that kept my last 100 copied strings. I didn’t realize Vim was doing this from 0-9 and I was ignorantly using named registers when I got myself in a jam.

It really pays to remember to use :help somefeature even when you think you know what somefeature does.

Andy Stewart

Thu, 10 Mar 2016 00:00:00 +0000

Who are you and what do you use Vim for?

I am a programmer who runs a small software-as-a-service business. I mainly write Ruby, Haml, Coffeescript and Bash.

I switched to Vim from an IDE in 2001. I knew the learning curve would be vertiginous but I’m an optimist and I thought it would pay off in the end. For the first few days I felt hamstrung while my Eclipse-using colleagues laughed at my fumbling efforts. Eventually I got the hang of it and was able to get half a day’s work done while they waited for Eclipse to launch.

Having decided to switch, I narrowed the choices down to Vim and Emacs. Both sounded powerful and worthwhile though Emacs also had its Lisp appeal. But my overriding concern was to minimise typing strain and on that basis Vim’s modal editing triumphed over Emacs’ chords. Also just-a-text-editor seemed neater to me than includes-a-text-editor.

These days I use Vim for everything plain text or software-related, which is pretty much everything. But not email; it’s always seemed too much hassle to get Vim working with Apple Mail. Recently I’ve started hoping that someone will figure out how to embed Neovim within Mail.

I’m on OS X and I use MacVim, currently 7.4.969 via Homebrew. I don’t follow the day to day commits to Vim or MacVim and I only upgrade every few months. Occasionally I might run into a specific bug, and I’ll modify the Homebrew recipe to re-build Vim with a patch from the mailing list, but that’s unusual.

I prefer the GUI version to the terminal version because the GUI fires focus events. I use FocusLost to avoid typing :w every time I switch away and FocusGained to pulse the cursorline and have vim-gitgutter automatically update all the visible buffers when I switch back to MacVim.

It’s good to see text editors in general flourishing at the moment, and the consequent cross-pollination of ideas.

One day I’d like to write a kind of Coffeescript for Vimscript, perhaps a bit like riml, but I’m not sure when I’ll ever have the time.

Introduce us to your Vim config.

I started from nothing and I’ve slowly built it up over time. I try to keep it as lean as possible and I never copy-paste stuff I don’t understand. As and when I change my config I try it for a few weeks before deciding whether to keep the change or drop it. Usually I drop it.

I’m not a fan of “distributions”, those large bundles of plugins and configuration. They might provide a short term benefit but I believe they hinder learning how unadorned Vim works, and they can easily bloat Vim. Vim’s got enough to wrap one’s head around without having to learn heaps of plugins at the same time.

I really value how easily one can read plugin source code on places like GitHub and BitBucket. It’s impossible on vim.org where all the code is hidden away inside zip files.

Alongside Pathogen to manage Vim’s path, I use my own plugin “manager”, voom, to install, update and uninstall plugins. It’s a 100 line bash script. I looked at the plugin managers out there and they’re all hundreds if not thousands of lines of Vimscript. At the end of the day all I want to do is download some files to disk and maybe make some symlinks. If you use Vimscript you’re going to end up calling out to bash to do that, with the added fragility of Vim’s system(), so why not cut out the middleman and just do it in bash? To my mind that’s the simplest thing that works.

I believe the biggest problem afflicting Vim plugin development is the lack of a way to express dependencies. Every other language has a dependency mechanism for its libraries. Vim doesn’t and as a result every plugin has to reimplement (and debug) the same utility functions over and over again.

For example it would be great to have a plugin which simply provides an easy-to-use DSL over Vim’s clunky signs commands, and avoids the gotchas when handling signs. Instead every plugin which uses signs has to re-implement the same functionality.

To make this happen we need a standard way to express dependencies. JSON would make a good format: Vim reads it natively as of v7.4.1154 (and it’s easy to parse in Vimscript for earlier versions). Once the dependency file has been agreed, plugin authors could add it to their plugins and plugin managers could start to use it.

Anyway, you can see the plugins I use here.

Vim users navigate their buffers and files all the time. You want this to be as efficient and intuitive as possible. Efficiency is objective but intuitive-ness is subjective, which is why there are so many plugins in this area. Personally I like bufexplorer for buffers though it would be nice to drop the old winmanager integration and incorporate git-status information. I invoke it all the time so I [map ][map-cr] to open it - much faster than the default `be`.

To open files I either use filebeagle if the file is near the current buffer’s file or a fuzzy finder. I think fuzzy finders are great; I have tried several though I haven’t really settled on one. Originally I used PeepOpen but I can’t get it installed on El Capitan. I would use selecta if it worked with MacVim. Currently I used probe which does the job nicely. I keep meaning to try out Unite which seems like it could replace bufexplorer, filebeagle and probe…but with 4,000 lines of instructions I never feel I have enough time available to get to grips with it properly.

I don’t use tabs; more accurately the only time I use a second tab is for reading the help docs.

I’ve also tried several alignment plugins. You need to give them three pieces of information: which lines to align, what character(s) to align on, and what alignment you want. Each plugin has a different way to specify these three things and lion is the only I can use without having to check the docs each time.

Colorscheme-wise I use solarized-dark. I find dark backgrounds easier on the eyes, and while I have no idea what to make of solarized’s colour-science stuff, I do like its colours.

For a long time I used airline for my status line. But I like keeping things minimal and I was trying to configure it not to display various of its bits and bobs and it took me ages to figure out. I realised it was crazy to install a huge statusline manager and then spend time figuring out its custom syntax in order to turn off most of its output.

So I spent 10 minutes deciding what I did and did not want to see in my statusline, e.g. not the current line because I can look at the line number in the margin. And then I spent 10 minutes reading :help statusline. And then I uninstalled airline and spent 30 minutes or so implementing exactly what I wanted and fiddling with the colours. Very satisfying!

I like the file path: the filename stands out while the the relative path is there if you need it. I haven’t see this two-colour innovation anywhere else and I trust it will lead to fame and fortune. I use the window number for jumping around (see below).

Everything else is fairly standard I think. I use the default leader key. I’ve never wanted to change it, though I saw a suggestion somewhere to use the space bar instead which sounded like a promising idea.

I like mappings which augment, rather than replace, Vim’s built-in commands. For example:

" Use | and _ to split windows (while preserving original behaviour of [count]bar and [count]_).
nnoremap <expr><silent> <Bar> v:count == 0 ? "<C-W>v<C-W><Right>" : ":<C-U>normal! 0".v:count."<Bar><CR>"
nnoremap <expr><silent> _     v:count == 0 ? "<C-W>s<C-W><Down>"  : ":<C-U>normal! ".v:count."_<CR>"

I turn off Vim’s backups and swapfiles because they solve problems I don’t have and introduce new ones I don’t need.

I used to think that one day I’d properly analyse how I use Vim, along the lines of Seth Brown’s Vim Croquet or Drew Neil’s Vimprint, to discover ways I could squeeze out a little more efficiency. Now I think it couldn’t possibly be worth the time.

What have been the most useful resources for you to learn Vim?

When I started I read the 7 Habits Of Effective Text Editing and the first few chapters of Vim’s manual. After that I used :help and :helpgrep to look up anything I didn’t know, which was just about everything.

I looked up and learned what every key on the keyboard did in normal mode, and then tried to use each one where appropriate.

Early on I found an excellent reference card which I stuck to my monitor. I crossed off each line as I learned it, which kept alive the hope of ever being able to use Vim well.

More recently Drew Neil’s Vimcasts were excellent.

These days for Vimscript I turn to Steve Losh’s Learn Vimscript the Hard Way and, of course, I look on GitHub at how people have already solved whatever problem I’m stuck on.

What’s the most recent thing you’ve learned about Vim?

I just learned how to implement custom completion, which turned out to be easy. I’ve been typing a lot of German recently and I wanted to be able to auto-complete accented letters instead of learning a few digraphs.

Neovim-wise I recently looked at its job control mechanism so vim-gitgutter can run its diffs asynchronously. Vim itself has just added async capability in v7.4.1274 though it’s not clear how stable the API is yet.

How did you get started writing Vim plugins?

Geoffrey Grosenbach, of PeepCode (now Pluralsight), asked me to write a plugin for PeepOpen, a desktop app for switching between files in text editors. I had previously volunteered to write a PeepCode screencast on Vim, so when he built PeepOpen he asked me to provide a plugin.

I had never written a Vim plugin before and it took me hours to write those 30 lines of Vimscript. The part I found confusing was linking up functions, commands, and maps. Even today I find this part of Vim unintuitive.

Once Vim was able to talk to PeepOpen, Geoffrey asked me to write something to automatically change Vim’s working directory to the project root. This is vim-rooter. Having Vim change directory automatically isn’t everybody’s cup of tea – but I like it and it helps when working on two projects in the same session, e.g. a Rails app and a gem dependency.

Your most well-known plugin is probably vim-gitgutter. What can you tell us about the story of its development?

Six years ago I read a blog post entitled Cyclomatic Complexity in Vim: First Steps. In it Gary Bernhardt, who later went on to make the Destroy All Software screencasts, got Vim to highlight the complexity of each function in the margin (a.k.a. SignColumn). I had never seen Vim do anything like it and I wanted to do something similar myself…but I couldn’t think of anything suitable.

Three years later I read a blog post entitled GitGutter. JD Isaacks had written a Sublime Text plugin to show git-diff markers in the margin. I thought it was interesting, though not very useful, and looked for a Vim version to try. I couldn’t find one; and I realised this was the excuse I’d been looking for to try doing something with the SignColumn.

I wrote the first version in a day or two. It was the simplest thing that worked: a proof of concept really. It didn’t have any realtime updating and it was slow, but it made me happy because I had finally got the SignColumn doing something. And to my great surprise I found it useful after all.

After that it was mainly a question of speeding it up. So instead of processing all buffers when it ran, I made it process only the visible ones. I measured and found Vim was taking 7ms to place each sign. On a file with 142 signs, that meant Vim freezing for 1s every time the plugin ran – even if the diff hadn’t changed. So instead of throwing away all the signs and adding them from scratch each time, I diffed the diff and “upserted” the signs, which made a big difference. After that I kept re-profiling and concentrating on the worst remaining hotspot, and eventually it got to the point where it seemed more or less instant to me.

The part of the code which has churned the most is the function which calls out to git-diff. Initially there was no realtime diffing so I could just call git diff FILE. Realtime diffing meant sending the contents of the buffer, without saving it, to git-diff. So I passed the buffer’s contents as the second argument to system()…but it turned out that didn’t work with repos which automatically adjust line endings. So now I pass two files to git-diff: a temp file holding the buffer’s contents and a temp file for the file in the index (git show :file > tmpfile).

Then it became apparent that using new temp files each time, even if they are never loaded into vim, makes the buffer numbers sky-rocket; after a day I would find my buffer numbers were in the thousands. So I started reusing temp files…but then it turned out you have to preserve the real file’s extension or git’s line ending conversion goes awry.

Also I found that writing the buffer’s contents to a temp file resets various marks, so I had to restore those afterwards. And then Windows requires a random extra pair of parentheses around everything. And so on.

And then there were a number of unexpected problems with grep. I use grep if it’s available to filter git-diff’s output for the hunk information because it’s more efficient than piping lots of unnecessary data back for Vimscript to filter. But it turns out some people have grep always return colourful output, which breaks things. So then I passed the --color=never flag to grep, but some greps don’t support it. So then I auto-detected whether or not grep supports --color=never but that slowed down Vim’s startup. Et cetera.

Initially there were no tests. But after I found a couple of gotchas with Vim’s signs “API”, I realised I had to write tests to avoid re-introducing bugs I’d already fixed. I’d never written Vimscript tests and, as far as I knew, there was no de-facto standard way to test. I looked at half a dozen testing plugins but none clicked with me. I eventually decided to follow Christian Wellenbrock’s approach in targets.vim: just use bash. My tests have many disadvantages, e.g. you can’t easily run a single test, but on the plus side, they work. I don’t know if I’d do it the same way again.

Overall the biggest surprise for me is how useful I find vim-gitgutter: both the diff markers and the hunk staging. I used to git add -p all the time and now I never do: I stage all hunks with vim-gitgutter.

In Vim you’re constantly moving between windows. When I have fewer than four or five open, I use tab and shift-tab to cycle between them to the one I want.

" Use tab and shift-tab to cycle through windows.
nnoremap <Tab> <C-W>w
nnoremap <S-Tab> <C-W>W

With more windows, I find it quicker to jump directly to the one I want. My status line shows each window’s number so I can type \7 to jump straight to window 7.

" Source: http://stackoverflow.com/a/6404246/151007
let i = 1
" If I have more than 9 windows open I have bigger problems :)
while i <= 9
  execute 'nnoremap <Leader>'.i.' :'.i.'wincmd w<CR>'
  let i = i + 1
endwhile

It’s not rocket science but it saves me lots of time. Which is the whole point of Vim.

What have you been working on recently in Vim?

I recently used Vim over ssh on my phone to fix a production bug while I was away from my computer. With a low-bandwidth connection I was very glad of Vim’s succinct keystrokes – which, I believe, were originally motivated by having to edit text over 300 baud modems. It felt like an apt use of Vim.

Chris Oliver

Mon, 07 Mar 2016 00:00:00 +0000

Who are you and what do you use Vim for?

I’m Chris Oliver. I’m a developer and entrepreneur who spends a lot of his time bridging the business and engineering side of startups. Originally I got started programming around 7th grade when my dad gave me a book on programming Basic on the Atari he used to have. Since we didn’t have the Atari anymore, I discovered our Magnavox computer in the basement could run GW-Basic which was similar enough. Over the years I taught myself a bunch of languages and went to college for a Computer Science degree.

It’s hard to say when I first used Vim, but it was probably 6 or 7 years ago that I first started using it full-time. I use it mostly for web development writing mostly Ruby, Rails, CSS, JS, CoffeeScript, Erb, etc. I’m currently using MacVim on OS X because it provides a little bit more natural interface when other people use my computer. If they’re used to clicking and highlighting things in Sublime, they can have an easier time pairing with me using Vim.

There were a few reason why I chose Vim. One was that I originally did tons of work on Linux. Anytime you have to SSH into a server you usually have two options by default: Vim or Nano. Since Nano is pretty basic, I figured learning Vim would be a wise choice. It also seemed like it was the most popular when I was starting so I figured I’d be able to learn it easier because of that.

Introduce us to your Vim config.

I’m one of the least advanced users of Vim you might find, but I know enough of the basics that my velocity of editing is quite a bit faster than most people who use Sublime or Atom that I’ve worked with. My Vim setup is a pretty stock setup, with one big addition: a thing called Janus. Janus is a well maintained repository of Vim plugins and mappings that provide you a really nice environment to ease into if you’re coming from a graphical editor like Sublime or Atom and want to get into Vim.

The common question I get from most web developers is why would I use Vim over Atom or Sublime? The answer to that is pretty simple. When you use Vim, you’re encouraged to be using the keyboard 100% of the time. That’s going to increase your typing efficiency a lot. When you’re in Sublime, you’ll notice you have a tendency to continuously move your hand between the keyboard and mouse and everything’s slower then. Sure, at this point graphical editors provide a lot of the same shortcuts or Vim modes, but they’ll never put you in the right mindset of typing efficiency that using Vim does.

In the early days, I struggled using Vim because I wanted to see my files, quickly edit files, etc. Everything felt like sort of a chore because there were so many commands to memorize. All those comfortable things of using Sublime feel missing the moment you step into stock Vim. Janus promised to ease you in and was one of the more popular distributions at the time so I figured I’d give it a shot. I’ve been using it ever since. At some point I’ll build my own custom Vim set of plugins and configs, but for right now Janus gets the job done well for me.

The plugins I use the most are CtrlP, NerdTree, and Ack which give you a pretty good chunk of the features you’d use most in an editor like Sublime. Syntastic is always great for a quick gut check to make sure you didn’t leave any syntax errors in your file while editing. It’s caught a lot of quick bugs that I wouldn’t have noticed as quickly.

What have been the most useful resources for you to learn Vim?

I’ve quite enjoyed watching Gary Bernhardt and Ben Orenstein talk about how they use Vim. Those guys are quite inspirational when it comes to deciding whether or not you should learn Vim. Vimcasts has also been a good inspiration for diving deeper into vim. I’m still just a beginner with vim, so it’s always awesome to see how the pros use it to pick up one or two things that make your daily typing faster.

What’s the most recent thing you’ve learned about Vim?

I was just reading this thread on Stack Overflow recently and didn’t realize you could use “gv” to select the most recent visual select. Super cool stuff.

Are you involved in a local Vim community?

Not currently, but I would love to get more involved in the future!

What have you been working on recently in Vim?

Lately I’ve been mostly using Vim to work on GoRails screencasts. I do all the coding for my Rails apps in Vim, so if you’re interested to see how I use it, definitely check out the screencasts.

I’m also maintaining a bunch of open source projects and doing a couple consulting projects at the moment. Pair programming on these projects is always fun because it usually results in the person I’m working with start trying out Vim for their own workflow shortly afterwards.

How I Vim

Karl Yngve Lervag

Who are you and what do you use Vim for?

Introduce us to your Vim config.

Tell us the story behind vimtex.

Share a snippet of Vim script you’ve written and talk about what it does.

Links

Kuniwak

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

Tell us about your project vint.

Are you involved in a local Vim community?

Links

Kassio Borges

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

How did you get started writing Vim plugins?

Tell us the story behind your plugin neoterm.

Are you involved in a local Vim community?

Share a snippet of Vim script you’ve written and talk about what it does.

Links

Daniel Schauenberg

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

How did you get started writing Vim plugins?

Tell us about your plugin simplenote.vim.

Are you involved in a local Vim community?

Share a snippet of Vim script you’ve written and talk about what it does.

What have you been working on recently in Vim?

Links

Gabriel Berke Williams

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

How did you get started writing Vim plugins?

Links

Josh Branchaud

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

Are you involved in a local Vim community?

Share a snippet of Vim script you’ve written and talk about what it does.

What have you been working on recently in Vim?

Links

Artur Shaikhullin

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

How did you get started writing Vim plugins?

Are you involved in a local Vim community?

Share a snippet of Vim script you’ve written and talk about what it does.

What have you been working on recently in Vim?

Links

Andre Torrez

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

Links

Andy Stewart

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?

What’s the most recent thing you’ve learned about Vim?

How did you get started writing Vim plugins?

Your most well-known plugin is probably vim-gitgutter. What can you tell us about the story of its development?

Share a snippet of Vimscript you’ve written and talk about what it does.

What have you been working on recently in Vim?

Chris Oliver

Who are you and what do you use Vim for?

Introduce us to your Vim config.

What have been the most useful resources for you to learn Vim?