Skip to content

Instantly share code, notes, and snippets.

Created July 27, 2014 10:08
Show Gist options
  • Save chibicode/23f1259455877c76cab0 to your computer and use it in GitHub Desktop.
Save chibicode/23f1259455877c76cab0 to your computer and use it in GitHub Desktop.
Goodbye Vim, Hello Sublime Text, and My Final .vimrc
" vim:fdm=marker
" Vundle {{{
set nocompatible
filetype off
set rtp+=~/.vim/bundle/vundle/
call vundle#rc()
Bundle 'airblade/vim-gitgutter'
Bundle 'bling/vim-airline'
Bundle 'chriskempson/base16-vim'
Bundle 'coot/cmdalias_vim'
Bundle 'gmarik/vundle'
Bundle 'jiangmiao/auto-pairs'
Bundle 'JulesWang/css.vim'
Bundle 'junegunn/vim-easy-align'
Bundle 'kana/vim-textobj-indent'
Bundle 'kana/vim-textobj-line'
Bundle 'kana/vim-textobj-user'
Bundle 'kien/ctrlp.vim'
Bundle 'Lokaltog/vim-easymotion'
Bundle 'matze/vim-move'
Bundle 'mbbill/undotree'
Bundle 'nelstrom/vim-textobj-rubyblock'
Bundle 'ntpeters/vim-better-whitespace'
Bundle 'rking/ag.vim'
Bundle 'scrooloose/nerdtree'
Bundle 'scrooloose/syntastic'
Bundle 'sheerun/vim-polyglot'
Bundle 'szw/vim-ctrlspace'
Bundle 't9md/vim-choosewin'
Bundle 'terryma/vim-expand-region'
Bundle 'terryma/vim-multiple-cursors'
Bundle 'thinca/vim-visualstar'
Bundle 'tpope/vim-commentary'
Bundle 'tpope/vim-dispatch'
Bundle 'tpope/vim-endwise'
Bundle 'tpope/vim-eunuch'
Bundle 'tpope/vim-fugitive'
Bundle 'tpope/vim-git'
Bundle 'tpope/vim-repeat'
Bundle 'tpope/vim-surround'
Bundle 'tpope/vim-unimpaired'
Bundle 'Valloric/YouCompleteMe'
Bundle 'vim-scripts/IndexedSearch'
Bundle 'wesQ3/vim-windowswap'
Bundle 'zhaocai/GoldenView.Vim'
Bundle 'chibicode/dwm.vim'
Bundle 'chibicode/CRDispatcher'
" }}}
" Base Config {{{
filetype plugin indent on
set background=dark
colorscheme base16-flat
syntax on
let mapleader = ","
runtime macros/matchit.vim
set autoindent
set autoread
set backspace=indent,eol,start
set binary
set cmdheight=2
set complete-=i
set completeopt=menuone,preview
set equalalways
set expandtab
set fillchars+=stl:\ ,stlnc:\
set foldmethod=indent
set foldnestmax=3
set hidden
set history=10000
set ignorecase
set incsearch
set hlsearch
set infercase
set laststatus=2
set lazyredraw
set nobackup
set nofoldenable
set noswapfile
set nowritebackup
set number
set numberwidth=4
set ruler
set scrolloff=3
set shell=/usr/local/bin/zsh
set shiftwidth=2
set shortmess=atI
set showcmd
set showmatch
set showtabline=2
set sidescroll=1
set sidescrolloff=15
set smartcase
set softtabstop=2
set splitright
set synmaxcol=1000
set t_Co=16
set t_ti= t_te=
set tabstop=2
set textwidth=0
set title
set ttyfast
set undodir='/tmp'
set undofile
set visualbell
set whichwrap=b,s,h,l,<,>,[,],~
set wildignore=.git,.hg,*.o,*.a,*.class,*.mo,*.la,*.so,*.obj,*.swp,*.jpg,*.png,*.xpm,*.gif,*.pyc,*.swf,*.egg,*.jar,*.dump,*.gem
set wildmenu
set wildmode=longest,list
set wrap linebreak textwidth=0
" }}}
" Fix Paste {{{
" I haven't found how to hide this function (yet)
function! RestoreRegister()
let @" = s:restore_reg
return ''
function! s:Repl()
let s:restore_reg = @"
return "p@=RestoreRegister()\<cr>"
" NB: this supports "rp that replaces the selection by the contents of @r
vnoremap <silent> <expr> p <sid>Repl()
" }}}
" Autocmd: Basic {{{
augroup vimrcEx
" Remove all previously defined autocmds
" Automatically create parent directory on save if directory doesn't exist
au BufWritePre * if expand("<afile>")!~#'^\w\+:/' && !isdirectory(expand("%:h")) | execute "silent! !mkdir -p ".shellescape(expand('%:h'), 1) | redraw! | endif
" Move to the last edited location
au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g'\"" | endif
" Fugitive - remove when done
au BufReadPost fugitive://* set bufhidden=delete
" Force syntax highlighting for bufdo
au BufWinEnter * nested if exists('syntax_on') && ! exists('b:current_syntax') && ! empty(&l:filetype) | syntax enable | endif
au BufRead * if exists('syntax_on') && exists('b:current_syntax') && ! empty(&l:filetype) && index(split(&eventignore, ','), 'Syntax') != -1 | unlet! b:current_syntax | endif
" Resize splits when the window is resized
au VimResized * exe "normal! \<c-w>="
au BufNewFile * set noeol
" Track Quickfix Window
au BufWinEnter quickfix call GetQuickFixBufferNumber()
au BufWinLeave * call CheckIsQuickfixWindowClosing()
" }}}
" Autocmd: Files {{{
au BufWinEnter,BufRead,BufNewFile Gemfile set ft=ruby
au BufWinEnter,BufRead,BufNewFile Rakefile set ft=ruby
au BufWinEnter,BufRead,BufNewFile Guardfile set ft=ruby
au BufWinEnter,BufRead,BufNewFile Thorfile set ft=ruby
au BufWinEnter,BufRead,BufNewFile Gruntfile set ft=javascript
au BufWinEnter,BufRead,BufNewFile *.fdoc set ft=yaml
au BufWinEnter,BufRead,BufNewFile *.md set ft=markdown
au BufWinEnter,BufRead,BufNewFile *.slim set ft=slim
" Automatically reload vimrc when it's saved
au BufWritePost .vimrc source ~/.vimrc|set fdm=marker|AirlineRefresh
au FileType vim set fdm=marker
au SourceCmd .vimrc set fdm=marker|AirlineRefresh
au FileType slim set commentstring=/\ %s
if did_filetype()
if getline(1) =~# '^#!.*/bin/env\s\+node\>'
setfiletype javascript
if getline(1) =~# '^#!.*/bin/env\s\+ruby\>'
setfiletype ruby
" }}}
" Autocmd: Plugin Bookmarks (Command Aliases) {{{
au VimEnter * CmdAlias ea EasyAlign
au VimEnter * CmdAlias ut UndotreeToggle
"au VimEnter * CmdAlias vs call\ GoldenView#Split()
au VimEnter * CmdAlias tr StripWhitespace
au VimEnter * CmdAlias nt NERDTree
au VimEnter * CmdAlias --Plugins-- ---------------------
au VimEnter * CmdAlias d Dispatch
au VimEnter * CmdAlias dl RSpecLine
au VimEnter * CmdAlias df RSpecFile
au VimEnter * CmdAlias --Testing-- ---------------------
au VimEnter * CmdAlias ch e\
au VimEnter * CmdAlias vi tabedit\ ~/.vimrc
au VimEnter * CmdAlias so source\ ~/.vimrc
au VimEnter * CmdAlias vip tabedit\ .vimrc-private
au VimEnter * CmdAlias sop source\ .vimrc-private
au VimEnter * CmdAlias tm tabedit\ ~/.tmux.conf
au VimEnter * CmdAlias zs tabedit\ ~/.zshrc
au VimEnter * CmdAlias ---Files--- ---------------------
au VimEnter * CmdAlias j join
au VimEnter * CmdAlias r reg\ 123456789 1
au VimEnter * CmdAlias be bufdo\ e!
au VimEnter * CmdAlias ---Basic--- ---------------------
au VimEnter * CmdAlias a CmdAlias!
au VimEnter * CmdAlias q exec\ DWM_Close()
augroup END
" }}}
" Autocmd: ListToggle {{{
command! QToggle call QListToggle()
function! QListToggle()
if exists("t:quickfix_buffer_number")
silent! cclose
silent! botright copen 10
function CheckIsQuickfixWindowClosing()
if exists("t:quickfix_buffer_number") &&
\ expand("<abuf>") == t:quickfix_buffer_number
unlet! t:quickfix_buffer_number
function GetQuickFixBufferNumber()
let t:quickfix_buffer_number = bufnr('$')
" }}}
" Plugin: Vim-Skip {{{
let g:vimskip_disable_default_maps=1
let g:vimskip_mapforwardskip='f'
let g:vimskip_mapbackwardskip='F'
" }}}
" Plugin: Choosewin
nmap S <Plug>(choosewin)
let g:choosewin_overlay_enable=1
let g:choosewin_overlay_clear_multibyte=1
" }}}
" Plugin: DWM {{{
let g:dwm_map_keys=0
let g:dwm_master_pane_width="50%"
nnoremap <c-b> :call DWM_Rotate(0)<CR>
nnoremap <c-f> :call DWM_Rotate(1)<CR>
nnoremap <c-n> :NERDTreeClose<cr>:cclose<cr>:call DWM_New()<CR>
nnoremap F :call WindowSwap#MarkWindowSwap()<CR>:wincmd h<cr>:call WindowSwap#DoWindowSwap()<CR>
nnoremap Q :NERDTreeClose<cr>:cclose<cr>:exec DWM_Close()<CR>
" }}}
" Plugin: Better Whitespace {{{
hi link ExtraWhitespace Error
" }}}
" Plugin: GitGutter {{{
let g:gitgutter_enabled = 0
let g:gitgutter_realtime = 0
let g:gitgutter_eager = 0
let g:gitgutter_map_keys = 0
" }}}
" Plugin: Airline {{{
let g:airline_powerline_fonts = 1
let g:airline_theme="base16"
" }}}
" Plugin: CtrlSpace {{{
let g:ctrlspace_default_mapping_key="<tab>"
let g:airline_exclude_preview = 1
let g:ctrlspace_show_unnamed=0
let g:ctrlspace_show_key_info=1
let g:ctrlspace_load_last_workspace_on_start=1
let g:ctrlspace_save_workspace_on_exit=1
hi link CtrlSpaceSelected Visual
hi link CtrlSpaceNormal Normal
hi link CtrlSpaceFound Search
" }}}
" Plugin: Expand Region {{{
call expand_region#custom_text_objects({
\ 'ii' :0,
\ 'ai' :0,
\ })
call expand_region#custom_text_objects('ruby', {
\ 'ib' :0,
\ 'ab' :0,
\ 'im' :0,
\ 'am' :0,
\ })
" }}}
" Plugin: Easymotion {{{
let g:EasyMotion_do_mapping = 0
let g:EasyMotion_use_upper = 0
let g:EasyMotion_smartcase = 1
let g:EasyMotion_startofline = 0
map f <Plug>(easymotion-s2)
xmap f <Plug>(easymotion-s2)
omap f <Plug>(easymotion-t2)
map J <Plug>(easymotion-j)
map K <Plug>(easymotion-k)
hi link EasyMotionTarget Todo
hi link EasyMotionShade Comment
hi link EasyMotionTarget2First Todo
hi link EasyMotionTarget2Second Todo
hi link EasyMotionIncSearch IncSearch
hi link EasyMotionIncCursor Search
" }}}
" Plugin: CtrlP {{{
let g:ctrlp_clear_cache_on_exit = 0
let g:ctrlp_cache_dir = $HOME.'/.cache/ctrlp'
let g:ctrlp_switch_buffer = 'e'
let g:ctrlp_user_command = 'ag %s -l --nocolor -g ""'
let g:ctrlp_open_new_file = 'r'
let g:ctrlp_match_window = 'bottom,order:btt,min:1,max:40,results:40'
let g:ctrlp_map = ''
let g:ctrlp_prompt_mappings = {
\ 'ToggleType(1)': [''],
\ 'ToggleType(-1)': [''],
\ 'PrtExit()': ['<esc>', '<c-c>'],
\ 'AcceptSelection("h")': ['<H>'],
\ 'AcceptSelection("v")': ['<V>'],
\ 'PrtBS()': ['<c-h>', '<bs>'],
\ 'PrtCurLeft()': ['<c-b>'],
\ 'PrtCurRight()': ['<c-f>'],
\ 'PrtClearCache()': [','],
\ 'PrtExpandDir()': [''],
\ 'PrtInsert("c")': ['<c-p>'],
\ }
" }}}
" Plugin: Golden View {{{
let g:goldenview__enable_default_mapping = 0
let g:goldenview__enable_at_startup = 0
" 'e' for expand
nnoremap R :GoldenViewResize<cr>
" }}}
" Plugin: MultiCursor {{{
let g:multi_cursor_use_default_mapping=0
let g:multi_cursor_next_key='D'
let g:multi_cursor_prev_key='<c-p>'
let g:multi_cursor_skip_key='<c-x>'
let g:multi_cursor_quit_key='<c-c>'
" }}}
" Plugin: NerdTree {{{
let g:NERDTreeChDirMode=2
let g:NERDTreeAutoDeleteBuffer=1
let g:NERDTreeHijackNetrw = 0
let g:NERDTreeShowBookmarks = 1
let g:NERDTreeMinimalUI = 1
noremap <space> :NERDTreeToggle<CR>
noremap <leader>. :NERDTreeFind<CR>
" }}}
" Plugin: YouCompleteMe {{{
let g:ycm_key_detailed_diagnostics = ''
let g:ycm_key_invoke_completion = ''
let g:ycm_complete_in_strings=0
" }}}
" Plugin: WindowSwap {{{
let g:windowswap_map_keys = 0
nnoremap mw :call WindowSwap#MarkWindowSwap()<CR>
nnoremap mW :call WindowSwap#DoWindowSwap()<CR>
" }}}
" Plugin: Surround {{{
vmap s S
" Key: "-"
let g:surround_45 = "<% \r %>"
" Key: "="
let g:surround_61 = "<%= \r %>"
" Key: "``"
let g:surround_33 = "```\r```"
" }}}
" Plugin: Markdown {{{
let g:markdown_fenced_languages = ['ruby', 'erb=eruby', 'js=javascript', 'coffee']
" }}}
" Plugin: Move {{{
let g:move_map_keys = 0
vmap <c-j> <Plug>MoveBlockDown
vmap <c-k> <Plug>MoveBlockUp
" }}}
" Mappings: Escape {{{
vnoremap <c-@> <esc>
inoremap <c-@> <esc>
nnoremap <c-@> :noh<cr>
vnoremap <c-space> <esc>
inoremap <c-space> <esc>
nnoremap <c-space> :noh<cr>
" }}}
" Mappings: Regular Chars {{{
noremap ; :
noremap 0 g^
noremap ^ g0
noremap $ g$
noremap j gj
noremap k gk
nnoremap x "_x
nnoremap s :w<cr>
" R => Resize, Q => Close, D => MultiCursor
nnoremap C :QToggle<cr>
nnoremap <leader>q :qall!
" Select last paste
noremap gv `[v`]
" Use 'n'noremap to avoid conflict w/ surround
vnoremap < <gv
vnoremap > >gv
" Expand current file
cnoremap %% <C-R>=expand('%:h').'/'<cr>
" }}}
" Mappings: Control Keys {{{
" Clipboard
vnoremap <c-y> "+y
noremap <c-p> "+p
set pastetoggle=<F10>
inoremap <c-p> <F10><C-r>+<F10>
" Insert mode
inoremap <c-h> <bs>
inoremap <c-l> =>
" Command mode
cnoremap <c-p> <c-r>+
cnoremap <c-v> <c-r>"
cnoremap <c-a> <Home>
cnoremap <c-e> <End>
cnoremap <c-b> <Left>
cnoremap <c-f> <Right>
cnoremap <c-j> <t_kd>
cnoremap <c-k> <t_ku>
" Window navigation
" Use DWM
nnoremap <c-j> <c-w>j
nnoremap <c-k> <c-w>k
nnoremap <c-h> <c-w>h
nnoremap <c-l> <c-w>l
nnoremap <c-w>3 :vs<cr>:vs<cr>
nnoremap <c-w>4 :vs<cr>:sp<cr><c-w>h:sp<cr>
nnoremap <c-w>6 :vs<cr>:vs<cr>:sp<cr><c-w>h:sp<cr><c-w>h:sp<cr>
" }}}
" Postprocess: Load Private File {{{
if filereadable(".vimrc-private")
source .vimrc-private
" }}}

After 3 years of using Vim, I decided to make a switch to Sublime Text 3.

For the past year or so, I've used the following editors:

  • Terminal Vim: For editing code for work (mostly building a Rails app). Not using MacVim b/c I use tmux.
  • Sublime Text 3: For editing blog posts and other one-off text files.
  • TextMate 2: For finding-and-replacing on large projects. Much better at this than Vim/ST3.

From now on, I'll only be using ST3. Here are some reasons. TL;DR: Vim made me OCD about perfecting .vimrc, even though all I needed was an editor that's good enough.

  • I'm probably much faster at manipulating text in Vim than in ST3, but I also waste a lot of time re-configuring vim. My .vimrc never feels right, and I'm OCD about making it marginally more robust after each tweak. I edit my .vimrc at least once a week, which is bad. I always feel like I can come up with a slightly better way to remap keys. You can combine keys in Vim, so .vimrc's potential is unbounded. In contrast, ST3 is not as customizable, and hence there's an upper limit to the amount of configuration I'd do with ST3.
  • In addition, every now and then, I discover a new Vim bundle, which I expect to make me far more efficient than those n00bs using ST3, but I get disappointed every time. 80% of my Vim productivity comes from 20% of the core keystrokes and tools I use, and they are often not the shiny new bundles.
  • To make things worse, so many bundles seem to break randomly on terminal Vim, and it's usually impossible to debug. GitGutter plugin had performance issues on terminal Vim, and I just couldn't fix it. Also, bundles often don't play nicely with each other. For example, DWM.vim occasionally breaks NERDTree, and YankRing pretty much overwrites all of the basic mappings.
  • ST3, on the other hand, is slower at manipulating text but requires much less configuration, at least for someone OCD like me. This is the biggest reason why I made the switch.
  • I often do project-wide find-and-replace, and ST3 is much better at it than Vim is. Although TextMate 2 has a much nicer find-and-replace dialog, that's the only feature I'm using from TextMate 2, so I might as well use ST3 all the way.
  • Many plugins have become compatible with ST3/Package Control—this wasn't the case a year ago.
  • I hated ST3's vintage mode, mainly because I couldn't figure out how to remap keys or sync the settings with my .vimrc, but over the past year I got reasonably fast at ST3 without using the vintage mode. I was hoping for actualvim project to mature, but that didn't happen.

...Plus all the reasons outlined on: Just Use Sublime Text.

Vim is a lifelong journey. Even now I want to convert this text, which I wrote in Vim at 80 columns wide, to non-fixed width text, and I’m going to go search for how to do it. I’m probably going to learn something in the process. At year 4 of Vimming.

For me, life is too short to want to touch .vimrc every week.

My Final .vimrc on Gist

I've always feared that people would judge me as a non-serious programmer if I used ST3 instead of Vim or Emacs. I realized that I was wrong, but just as a record, I'll copy paste my no-longer-updated .vimrc here to demonstrate my current Vim knowledge (and OCD-ness).

See my .vimrc below...

Plugins Used

  • vim-gitgutter — Git changes on the sign column.

    As mentioned before, it slowed down occasionally and I couldn't figure out why.

  • vim-airline — Nice statusbar for Git.

    Works well out of the box.

  • base16-vim — The ultimate color scheme.

    Since its inception, lots of themes have been added. Check them out here.

  • cmdalias_vim — Create aliases for commands

    Useful for commands you don't use often.

  • vundle — Package manager for Vim plugins

  • auto-pairs — Pair parentheses and other delimiters

  • css.vim — Better syntax highlighting for CSS

  • vim-easy-align — Align code blocks

    Switched from Tabular, but forgot why I made the switch.

  • vim-textobj-indent — Useful with vim-extend-region.

  • vim-textobj-line — Useful with vim-extend-region.

  • vim-textobj-user — Useful with vim-extend-region.

  • ctrlp.vim — The best fuzzy file finder out there.

  • vim-easymotion — Vim motions on speed

    Easymotion is now maintained by @haya14busa, and he's awesome. Lots of improvements in 2.0.

  • vim-move — Move lines up and down.

  • undotree — Undo manager. I never used it though.

  • vim-textobj-rubyblock — Useful with vim-extend-region.

  • vim-better-whitespace — Trims whitespaces.

  • ag.vim — Project-wide search using ag, a faster version of ack.

    I place .vimrc-private in each project directory and do something like this:

    " Search Ruby
    nnoremap <leader><leader>r :Ag <Space>-G="*.rb" <S-Left><Left>
    " Search JavaScripts
    nnoremap <leader><leader>j :Ag <Space>-G="*.(js\|coffee)" --ignore-dir=public<S-Left><S-Left><Left>
    " Search Stylesheets
    nnoremap <leader><leader>s :Ag <Space>-G="*.(css\|scss)" --ignore-dir=public<S-Left><S-Left><Left>
    " Search View Files
    nnoremap <leader><leader>v :Ag <Space>-G="*.(html.erb\|html.slim\|slim)" <S-Left><Left>
  • nerdtree — Directory/File management

  • syntastic — Syntax checker

  • vim-polyglot — Syntax bundle

  • dwm.vim — Tiled Window Management for Vim

    My preferred way of window management, except it broke NERDTree and Quickfix too often.

  • vim-ctrlspace — The ultimate Vim buffer/session management.

    This is a new plugin and probably the most comprehensive buffer manager I've seen. Very high learning curve but recommended.

    <iframe width="1280" height="720" src="//" frameborder="0" allowfullscreen></iframe>
  • vim-choosewin — Like easymotion, but for windows

    Useful when I'm working on a big screen

  • vim-expand-region — Expand current selection

  • vim-multiple-cursors — Sublime-like multi-selection

    I use this feature a lot in Sublime, but not as often in Vim.

  • vim-visualstar — Make * work in visual mode

  • vim-commentary — Fast comment blocks

    Switched from NERDCommenter, but forgot why.

  • vim-dispatch — Run tests from Vim

    Integrates well with tmux. Protip: use execute 'Focus spring rspec %:' . expand(line('.')) to tell rspec to test the current line, and then do Dispatch.

  • vim-endwise — Automatically end in Ruby

  • vim-eunuch — Unix commands in Vim

  • vim-fugitive — Git in Vim. I use Gdiff and Gblame the most.

  • vim-git — Support plugin for fugitive

  • vim-repeat — Repeat plugin commands

  • vim-surround — Surrond code with delimiters

    Protip: for erb and markdown, use:

    let g:surround_45 = "<% \r %>"
    let g:surround_61 = "<%= \r %>"
    let g:surround_33 = "```\r```"
  • vim-unimpaired — A set of handy shortcuts

    I use [q and q] often.

  • YouCompleteMe — The ultimate completion manager

  • IndexedSearch — Show the number of occurrences in a search

  • vim-windowswap — Swap windows

  • GoldenView.Vim — Temporarily resize windows

    The only feature I use is GoldenViewResize. I let DWM.vim handle everything else.

Plugins I stopped using

These are all great plugins. I just wanted to keep my .vimrc minimal, harnessing as much default settings as possible.

  • lightline.vim — A light and configurable statusline/tabline for Vim.

    Why not? I switched from airline once, but didn't see much benefit, so I switched back.

  • thumbnail.vim — A thumbnail-style buffer selector for Vim.

    Why not? Too overkill for me.

  • tabman.vim — Tab management for Vim.

    Why not? Too overkill for me.

  • vim-signature — Plugin to toggle, display and navigate marks.

    Why not? I don't use marks. They're a pain to keep track of, and I try to keep my files small.

  • vim-indent-guides — A Vim plugin for visually displaying indent levels in code.

    Why not? I use terminal vim, and didn't work so great in it.

  • Delimitmate — Provides insert mode auto-completion for quotes, parens, brackets, etc.

    Why not? I liked auto-pairs better.

  • dragvisuals — Move around visual blocks.

    Why not? From More Instantly Better Vim. I use this feature a lot in Sublime Text, but not in Vim for some reason.

  • clever-f.vim — Extended f, F, t and T key mappings for Vim.

    Why not? Great plugin, but Easymotion covers my needs.

  • vim-skip — Simple movement script for Vim.

    Why not? Great plugin, but Easymotion covers my needs.

  • vim-startify — A fancy start screen for Vim.

    Why not? I stopped using sessions.

  • vim-signify — Show a VCS diff using Vim's sign column.

    Why not? I use vim-gitgutter instead, but forgot why I made that choice.

  • vim-unstack — Vim plugin for parsing stack traces and opening the files

    Why not? Awesome plugin, but my stack traces have never been too complicated.

  • vim-nerdtree-tabs — NERDTree and tabs together in Vim, painlessly

    Why not? Useful plugin if you use NERDTree heavily. I try to limit the usage of NERDTree, so wasn't too useful.

  • dwm.vim — Tiled Window Management for Vim

    Why not? Great plugin and used it for a really long time. I've since switched to GoldenView.vim.

  • vim-rspec — Run Rspec specs from Vim

    Why not? dispatch.vim did most of what I needed.

  • splitjoin.vim — A vim plugin that simplifies the transition between multiline and single-line code

    Why not? Seemed useful, but didn't use it enough.

  • trailertrash.vim — Identify and Irradicate unwanted whitespace at the end of the line

    Why not? Switched to vim-better-whitespace.

  • Buffet.vim — A vimplugin for switching and managing buffer lists

    Why not? Switched to Vim-CtrlSpace.

  • open-browser.vim — Open URI with your favorite browser from your favorite editor

    Why not? Used this mainly for markdown files, but I now use Sublime Text for editing markdown.

  • mru.vim — Most Recently Used (MRU) Vim Plugin

    Why not? Again, switched to Vim-CtrlSpace.

  • wildfire.vim — Smart selection of the closest text object

    Why not? Switched to vim-expand-region in favor of repeating capabilities.

  • Gundo.vim — Vim plugin to visualize your Vim undo tree.

    Why not? Switched to undotree.

  • rainbow_parentheses.vim — Color matching parentheses

    Why not? MatchPren was good enough for me.

  • vim-yankstack — A lightweight implementation of emacs's kill-ring for vim

    Why not? I switched from YankRing, but ended up just using registers.

  • Enchanted Vim — Persistent Very Magic Patterns in Vim Commands.

    Why not? I didn't use very magic often.

  • Syntax Files

    Why not? Switched to vim-polygot.

Thank you Vim, Hello Sublime

Looking forward to writing production code in ST3. I might come back to vim when neovim becomes stable.

I might post my ST3 config later. If you're looking for a resource on getting started with ST3, check out Sublime Productivity. If you're a TL;DR'er, check out Alex Maccaw's post.

If you have questions, message me on Twitter.P

Copy link

JulianCataldo commented Sep 24, 2016

Thanks for your write-up!
I have a reverse experience (ST3 user currently learning Vim) and now I can keep in mind your experience.
ST3 will remain my main editor for now, yet knowing basic Vim is still mandatory for ssh-ing. It's available nearly anywhere and more flexible than nano, so :)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment