I've been using Vim as my text editor for a little while now and I feel like I'm taking the long way to do anything. I use ctags to tag my code base for navigation and I use grep (although inefficiently) to find where certain methods are used. But I have a feeling there are some very useful tools out there that I don't know about that could make me more productive.

What is the best software stack I could use for general programming that would complement Vim? How do you navigate a code base, run make, push changes to your source control system, etc? Do you have a 2nd console open next to Vim?

Vim itself. Maybe you are not using the correct plugins/scripts for the job. It depends on what kind of programming you're doing, what language, what other tools you need and so forth.
–
Mnemonic FlowAug 10 '10 at 21:08

I'm not specifying any language so as not to influence the responses I'll get. I'm not really looking for Vim plugins, although they are useful.
–
Louis SalinAug 10 '10 at 21:47

8 Answers
8

A great feature of vim is the ease of integration with existing shell commands. Some of the most useful external tools are the ones that are included in coreutils and other simple text maniplulation tools. For example, we can get the number of lines in a file with:

:! wc -l %

or the number of words:

:! wc -w %

Any command that works on the shell will work here. This can be powerfully combined with the :read (:r) command to put the output of the command into the file. For example:

:r !wc -l %

Will place the word line count into the file you are editing.

Another advantage of this is replacing the text you are currently editing with the output of one of these commands. For example, you could format the entire file with par by executing the command:

Whatever your language you'll want to use a feature called ctags that lets to browse around source definitions. This requires an external tool to generate TAGS files that are used by VIM to discover the locations of various code definitions within a project.

Get the exuberant ctags tool, it works for many many languages and is v simple to use.

from VIM :help ctags

ctags will create an index of all identifiers in a source tree. You can then use the tag commands to navigate around your source tree. see :help tag-commands. The easiest is to place the cursor over a keyword and press CTRL-]. To get back to where you came from press CTRL-T

Beyond this you might want to look at some of the VIM tips and improvements discussed here, it's a very comprehensive discussion of some of the things than can be done to improve a vimmer's experience.

Vim is a very powerful tool, I am sure all of you already know that. You'll start getting a productivity boost by using vim within a couple of weeks. But you will never saturate your knowledge of Vim. So, I for one am always on the lookout for new and efficient ways of doing things in Vim. There is a guy named Derek Wyatt who's done some great screencasts on the usage of the Vim, and also on the plugins he uses.

A few of the plugins which I use

command-t This makes browsing files a breeze, and it is very intelligent.

The Command-T plug-in provides an
extremely fast, intuitive mechanism
for opening files with a minimal
number of keystrokes. It's named
"Command-T" because it is inspired by
the "Go to File" window bound to
Command-T in TextMate.

fuzzyfinder I use this mostly to broswer buffers and change the current directory.

FuzzyFinder provides convenient ways
to quickly reach the
buffer/file/command/bookmark/tag you
want. FuzzyFinder searches with the
fuzzy/partial pattern to which it
converted an entered pattern

The NERD tree allows you to explore
your filesystem and to open files and
directories. It presents the
filesystem to you in the form of a
tree which you manipulate with the
keyboard and/or mouse. It also allows
you to perform simple filesystem
operations.

my favorite is cscope. If you have compiled vim with cscope support you can directly use cscope commands from VIM. e.g. searching for included file , functions called by xyz function etc.
I have tried it with very large source code repository. Its helps alot.

There's a great plugin for VIM that does syntax checking Syntastic. There are many other tools available as well for file management, building, etc. Go to IRC #vim on freenode.net, there are lots of helpful folks there.

If you are programming in any of the languages supported by GCC (C,C++,Java,Fortran) then Clewn is a great plugin that integrates the GDB debugger into VIM. I've actually found it to be one of the best interfaces to GDB that there is.

I usually set up a screen session for each project. Vim is in window 0, and I use window 1 for a shell session. If I'm coding in a language that has a decent REPL I usually run that in window 2. Of course, you don't need screen to do this; you could do it with different terminal windows or with tabs in a multitab terminal. I do find screen to be more stable than other alternatives: if your terminal app crashes, you can just start another terminal and reconnect to your still-running screen session. screen is also very quick to navigate in once you learn it (much like vim itself).

I mostly end up using the shell session for complicated version control activities like rebasing or merging: simpler things can be done from vim's command line (e.g. :!git commit % -m 'Added info aboutscreen.') or by using the fugitive addon. I find fugitive's :Gmove (rename the current buffer both in vim and in the git index) and :Gdiff (invoke vimdiff on the current buffer with a previous point in its history) particularly useful. You can also do things like building up a commit message in a scratch buffer, copying in text from various parts of your code, and then committing with :%!git commit -F /dev/stdin

I'll also use the shell session for functional/integration testing if that's applicable to whatever I'm working on, for example if I'm writing a command-line utility.

Vim's quickfix functionality is useful for debugging, though there seems to be a different addon required for each language you might want to work in. They also seem to use a variety of invocation techniques, mapping to function keys or to key sequences starting with \ or ,, or to custom commands, or by being automatically invoked when a buffer is saved. So far I haven't really bothered to suss this out, and just read unit test or lint results into a scratch buffer using e.g. :r !python -m doctest whatever.py. Modify code, switch back to the scratch buffer, u to undo, then hit :r and the up arrow (most of the time) to get that command back. But it may be worth your while to seek out an addon for this, depending on what language you work in.

For popular compiled languages like C, java, etc., :make will do a build, and support for the quickfix list is well established. So you can then do :copen to display the quickfix buffer. It will show a list of errors, one per line; hitting Enter on a line will jump your other window to that point in that file.

If you're working with multiple projects at a time, you can do :lmake to arrange for a list of errors to be stored in the location list: this is like the quickfix list but is associated with a single window rather than being a singleton within your vim instance. :lopen will open a location list for the current window.