Daily Vim: Text Editor Tips, Tricks, Tutorials, and HOWTOs

Vimgrep Tips

2009-12-09T05:58:00.000-08:00

I've mentioned vimgrep in a previous post, but I neglected to mention a few useful flags that can be used in conjunction with it.

If you apply the 'g' flag to your vimgrep, it will return all matches instead of just one match per line.

:vimgrep /foo/g **/*

If you apply the 'j' flag, Vim will not automatically jump to the first match.

:vimgrep /foo/j **/*

Thanks to Chanel for pointing these out.

More on Text States

2009-12-03T06:38:00.000-08:00

A few people have asked me for more information on text states. An anonymous reader contributed the following in the comments of my previous post on the topic.

Using g+ and g- is very different than using u and ^r.

Try following:
* Create new file
* (in normal mode) Type iOne - Esc
* Type oTwo - Esc
* Type oThree - Esc
* Type oFour - Esc
* Type oFive - Esc
* Type 2u
* Type oSix - Esc
* Type oSeven - Esc

Now you have an undo tree with 2 branches. Typing u only goes up the last branch. Using g- goes up by time - branch doesn't matter here.

Have a look in :help usr_32.txt for good explanation of using the undo tree.

Thanks to whomever contributed the tip!

Indent From Normal Mode

2009-12-02T05:12:00.000-08:00

From normal mode, pressing == will indent the current line.

Starting on a Specific Line

2009-12-01T06:55:00.000-08:00

An anonymous reader writes:

You can open a file on the command line and automatically put the cursor on the last line by typing:

vim + file

If you want vim to start at a specific line you can do the following instead:

vim +LINENUMBER file

Thanks for the tip!

Text States

2009-11-30T06:21:00.000-08:00

If you're using Vim 7+, you can use g- and g+ to go between text states. For a more advanced usage see the :help earlier and :help later.

Jumping to a Buffer

2009-11-24T06:11:00.000-08:00

If you have split windows open with multiple buffers, you can jump directly to a specific buffer number by doing the following:

N<C-w><C-w>

N is the window number you want to move the cursor to.

Thanks to Duff for the coffee!

Indent From Insert

2009-11-23T06:52:00.000-08:00

In the comments of my last post, graywh left a great tip that I didn't know about. If you're working in insert mode, you can change the indent level of the current line using <C-t> and <C-d>. These commands work no matter where your cursor is positioned on the current line and adjust the indent level based on your shiftwidth setting.

Shift-Tab'ing

2009-11-19T06:04:00.000-08:00

I have the following in my vimrc:

set sts=4
set et

This allows me to take advantage of the convenience of the tab key when editing while actually inserting spaces into the current buffer. Intuitively I've always wished I could shift-tab to unindent the current line one tab stop. After a minute of fiddling with my vimrc, I found a solution.

imap <S-Tab> <C-o><<

I should also mention that << and >> shifts the provided text based on your shiftwidth setting.

The Tao of Programming

2009-11-17T07:34:00.000-08:00

I stumbled onto this quip recently and found it particularly poignant.

"A program should be light and agile, its subroutines connected like a string of pearls. The spirit and intent of the program should be retained throughout. There should be neither too little or too much, neither needless loops nor useless variables, neither lack of structure nor overwhelming rigidity." - The Tao of Programming, 4.1 - Geoffrey James"

Last Insert

2009-11-16T06:00:00.000-08:00

Hitting gi in normal mode will take you to the last location where you were in insert mode. This is great for bouncing back to where you were editing after browsing the current buffer from normal mode.

Last Directory Visited

2009-11-13T06:57:00.000-08:00

From the shell, typing "cd -" will take you to the last directory visited. This is useful from a command-line navigation perspective and from inside of shell scripts as well.

Last Command

2009-11-12T06:53:00.000-08:00

Hitting "fc" from a Bash shell invokes your default editor (hopefully Vim) on your last shell command and executes it after Vim exits. This is great for command-line history editing after the fact.

-e ENAME selects which editor to use. Default is FCEDIT, then EDITOR, then vi.

Window Scrolling

2009-11-11T06:48:00.000-08:00

Hit ctrl-e to scroll the current window down. Hit ctrl-y to scroll the current window up. An advantage of using these commands is that the cursor stays in the current location. Try it!

Reader Question: Tags?

2009-11-11T06:12:00.000-08:00

Daniel Näslund writes:

"I use tags a lot. But I'm annoyed by all those open files it leaves
behind. It would be great if the file opened with g] or Ctrl-] would be
closed with Ctrl-T. If the file had been previously opened it would
remain open.

Another thing is a way to close all files except those currently viewed."

I don't use tags too often, so perhaps another reader can answer that question, but if you want to make all buffers except for the current buffer hidden, you can type in the :on ex-command. If you want to hide modified buffers as well, you can do :on!.

If the desired behavior is to actually delete the buffer, and you know it's buffer # or filename, you can do the following:

:bdelete file1 file2 file3

or something like

:1,3bdelete

Lastly, if you want to use a script to accomplish this, there's the BufOnly.vim which provides a single command to unload all buffers except the current one.

http://www.vim.org/scripts/script.php?script_id=1071

Reader Question: MMM Mode?

2009-11-11T06:09:00.000-08:00

Chris Keating writes:

"Could you ask your readership if there's a vim equivalent for emacs MMM mode:
http://mmm-mode.sourceforge.net/

mmm mode basically allows you to have different syntax highlighting for different parts of your document. This is really handy when you have SQL embedded in strings, etc."

Anybody have any ideas?

Setting Options

2009-11-10T06:45:00.000-08:00

Typing :options will allow you to set options interactively from inside of Vim. Just choose a command set to edit, and edit from there. This is a nice way to discover new settings.

Undo Levels

2009-11-09T06:42:00.000-08:00

You can set the number of desired undo levels by issuing a :set undolevels=N ex command.

Autowrite

2009-11-06T06:50:00.000-08:00

If you're tired of Vim asking you if you want to save the current buffer, you can :set autowrite to avoid this. Be careful if you enable this settings as it relies on your own prudence to prevent accidents from happening.

Next and Previous Characters

2009-11-05T06:35:00.000-08:00

Hitting "^" will take you to the first non-blank character on the current line. Hitting the Enter key will take you to the first non-blank character on the next line. Hitting "-" will take you to the first non-blank character on the previous line. All these should be executed from normal mode.

Beginning and End of a Buffer

2009-11-04T06:32:00.000-08:00

Hitting "gg" in normal mode will take you to the first line of the current buffer. Hitting "G" will take you to the end of the current buffer.

Grab A Ruler

2009-11-03T06:30:00.000-08:00

If you :set ruler in your vimrc, you'll retain a constant ruler at the bottom of your editing window. It contains the same statistics as provided by ctrl-g and allows valuable information to be gleaned with a quick glance.

Knowing Where You Are

2009-11-02T06:27:00.000-08:00

If you want to know the current filename, what percentage of the current file you're editing, whether the current file has been modified, or the character or line position, all you have to do is hit ctrl-g from normal mode inside Vim.

Repeat Last Substitution

2009-10-30T21:40:00.000-07:00

If you want to repeat your last substitution on the current line hit the "&" character from normal mode.

Quick Exits

2009-10-30T21:25:00.001-07:00

Hitting ZZ in normal mode will exit and save the current file. Hitting ZQ will exit without saving.

Handy Shell Pattern

2009-10-30T08:41:00.000-07:00

When piping commands, you can often benefit from breaking your data into multiple lines. A combination of sed and xargs can make this very easy to do. Take the following commands for example:

cd /tmp && mkdir blah && cd blah;
touch file-1 file-2 file-3;
ls | sed 'p; s/-//' | xargs -n2

Breaking this down, we create a directory and touch three empty files. From there, we use sed to print two lines. The first line is the original file name, the second line is the filename without the dash. From here, we can use the -n argument in conjunction with xargs to merge the two lines back into a single line. The resulting output would be:

file-1 file1
file-2 file2
file-3 file3

Once you have the lines joined, you could do something like:

... | while read a b; do mv $a $b; done

Bonus tip: the "read" bash builtin takes a line and associates each word with a given variable. Type "help read" from the shell for the complete documentation.

In summary the full command-chain for this tip would be:

cd /tmp && mkdir blah && cd blah;
touch file-1 file-2 file-3;
ls | sed 'p; s/-//' | xargs -n2 | while read a b; do mv $a $b; done

Thanks to Chris Sutter for contributing this handy shell pattern, and thanks to Andeers for the coffee!

Fun With Unicode ٩(●̮̮̃•̃)۶

2009-10-23T05:57:00.000-07:00

Following up on the last post, you can also use CTRL-V to enter unicode characters. All you have to do is the following:

CTRL-V u (unicode character hex code)

Note that you can also combine multi-byte characters as demonstrated in the title of this post.

CTRL-V for Literal Characters

2009-10-21T07:35:00.000-07:00

When typing in insert or ex mode, hiting CTRL-V allows you to enter a literal character. Some examples:

CTRL-V CTRL-M # enters a literal carriage-return \r
CTRL-V 10 <enter> # enters a null character

After entering the CTRL-V, you can either enter the character explicitly or type in its decimal code. A list of decimal codes is available through the :digraph ex command. If you're curious why this might be useful, I've used it on a number of occasions in conjunction with a substitution to remove binary characters from a file. An example might be:

:%s/CTRL-V CTRL-M//g # remove erroneous CTRL-M from the current file

You can find out the code for any character by putting it under the cursor and hitting "ga" in normal mode. For entering digraphs, you can also hit CTRL-K from insert mode and type the two letter character code preceeding the desired character.

Resizing with GNU Screen

2009-09-18T08:08:00.001-07:00

I know a lot of you use screen frequently. My friend Chris gave me a tip recently related to resizing split windows in a screen session.

In screen, you can do <C-a>:resize [+-]N<CR> to resize a window +/- N lines

This is handy if you've got a cmd running and want to see when it's done. You can split the screen, load it in one window, and resize it to be small; thereby, preventing it from occupying valuable real estate on your monitor.

Screen has a handful of : commands such as :number N to change the numeric position of the current window. Take a look at the DEFAULT KEY BINDINGS section of man(1) screen for the the full list (parenthesized next to each key binding).

For more screen tips, check out the screen extravaganza posted back in 2008.

Mouse Tips

2009-09-18T08:00:00.001-07:00

This has been mentioned on the blog in the past, but readers email me about it often enough that it deserves a formal tip. You can use the mouse to resize windows in Vim if you set your mouse as follows.

:set mouse=a

This will even work over a remote ssh session if you also set your term appropriately.

:set term=[the appropriate setting]

Options for term settings are as follows:

in the GUI: "builtin_gui"
on Amiga: "amiga"
on BeOS: "beos-ansi"
on Mac: "mac-ansi"
on MiNT: "vt52"
on MS-DOS: "pcterm"
on OS/2: "os2ansi"
on Unix: "ansi"
on VMS: "ansi"
on Win 32: "win32"

If the mouse setting interferes with your operating system's copy and paste ability such as the select to copy feature under X windows, you can revert to the standard behavior by holding shift while selecting text.

Setting your mouse as described also prevents accidental terminal scrolling with the mouse wheel when editing a file remotely and causes Vim to scroll within the current buffer instead.

Thanks to mmmattos for emailing me and providing the motivation for this tip.

Diffing From Inside Vim

2009-09-14T07:39:00.000-07:00

To compare two files without resorting to launching vidiff from the command-line, you can do the following.

1) open one of the two files in a standard buffer
2) type in :vert diffsplit filename

Put the name of the file you'll be comparing in place of filename. Prefixing the command with vert gives you a vertical split. If you'd prefer a horizontal split, simply omit the vert.

Types of Registers

2009-07-29T08:13:00.000-07:00

There was some mention of the special registers in Vim in the comments on my last post. Here's a list of all available registers in Vim (copied directly from the docs). For more info on what these registers do, please see :help registers.

There are nine types of registers:
1. The unnamed register ""
2. 10 numbered registers "0 to "9
3. The small delete register "-
4. 26 named registers "a to "z or "A to "Z
5. four read-only registers ":, "., "% and "#
6. the expression register "=
7. The selection and drop registers "*, "+ and "~
8. The black hole register "_
9. Last search pattern register "/

Insert Register Contents

2009-07-28T08:20:00.000-07:00

If you're in insert mode and would like to insert the contents of a given register without going into normal mode, you can hit ctrl-r and then input the desired register. Between typing ctrl-r and the second character, a '"' will be displayed to indicate that you are expected to enter a register.

An Introduction to Clojure's Agents

2009-06-19T05:40:00.000-07:00

For anyone that's interested in alternative programming languages, I've written a lengthy introduction to Clojure's agents.

For those unfamiliar with Clojure, it's a modern Lisp running on the JVM with excellent support for concurrency. It allows excellent interoperability with Java, so essentially you get a dynamic and clean programming language with a huge standard library. On the performance front, it's often on par with Java. I've spent a good deal of time learning the language lately, and I have to say that it's very enjoyable to work with.

One huge bonus of working with Clojure inside Vim is the VimClojure project. It allows interactive programming from inside of Vim and proxies code between a stateful NailGun server and the editor. To be honest, I wasn't aware that an interactive REPL was possible inside of Vim until I installed this, and I'm wondering if there are any other projects out there using similar techniques with different languages.

Switching from Horizontal to Vertical Split

2009-06-17T07:22:00.000-07:00

If you have two windows which are horizontally split, and you'd like to make them vertically split instead, the following command sequence works well:

<ctrl-w>t<ctrl-w>H

To orient them back to a horizontal split do this:

<ctrl-w>t<ctrl-w>K

Note that if the top (or left) window is already current you can omit the <ctrl-w>t and simply do <ctrl-w>H or <ctrl-w>K.

Vi Mode in Readline Applications

2009-06-15T05:51:00.000-07:00

Mike Pea submitted this comment in a recent tip, and I thought it deserved it's own post.

If you find that you do like using vi editing mode (and what's not to love about it :), add 'set editing-mode vi' to your .inputrc, and vi mode will work in any readline based client, eg psql, irb.

Thanks Mike!

Recursive Macros

2009-06-12T07:40:00.000-07:00

A friend at work pointed out to me yesterday that he had accidentally written a recursive macro in Vim. I had never thought about the fact that this was possible, but I'd imagine there could be some potential usefulness for these somewhere. As a trivial (and useless) example, here's a recursive macro to move the cursor to the end of the current line one step at a time: qal@aq

Edit: A little research has shown that this is an excellent way to repeat a macro to the end of the file. Say that you have a file containing one number per line from top to bottom:

123
234
345
456

Put the cursor on the first line and type the following:

qaq (clears register "a" of any previous macros)
qa<ctrl-a><enter>@aq

Now type @a once more, and the macro will run to the bottom of the file incrementing the value on each line by one leaving you with the following:

124
235
346
457

Screen in OS X Leopard

2009-06-05T06:46:00.000-07:00

Sorry for the horribly platform specific tip, but this has been annoying me, and I thought it might help someone. If you're running OS X 10.5, you may have noticed that screen destroys your path when you start it. This can easily be remedied by putting the following in your ~/.screenrc.

shell -/bin/bash

Vim + Eclipse = Eclim

2009-06-04T06:20:00.000-07:00

I know some of you may consider this to sacrilegious, but a lot of programmers are subjected to using Eclipse from time to time for various reasons. For those of you that need Eclipse for a given plugin, debugging session, or what have you, the Eclim project provides a flexible solution for integrating Vim with Eclipse.

Using Eclim gives you three options for how you'd like to integrate Vim and Eclipse. The least intrusive allows you to run a headless Eclipse and control it via Vim. This makes Eclipse act as sort of an app server, which Vim can pipe to and from.

The second option allows you to run both programs side by side. This way, Vim is still running standalone, but you can control Eclipse directly should you need to.

The final option allows you to embed Vim directly into Eclipse. You'll lose some screen real estate when using this option, but it may suit certain people's needs.

I'm not really a fan of Eclipse by any stretch of the imagination, but for things like Java debugging, it does offer some utility, so if you're in the same boat, you should give Eclim a try.

Recursively Replace Ctrl-M

2009-06-03T12:37:00.000-07:00

Ctrl-M's are a plague inflicted upon programmers everywhere. I've mentioned a number of ways to deal with them in the past, and some readers have also contributed helpful advice as well. Today I ran into a situation where I needed to do a huge source diff on two different directory trees. My preprocessor happened to strip out all Ctrl-M leading to a bunch of false positives on files that differed. Some Google'ing around lead me to find this gem, which recursively strips Ctrl-M on all files within a given directory.


for file in $(find /path/to/dir -type f); do
   tr -d '\r' <$file >temp.$$ && mv temp.$$ $file
done

In order to give credit where it's due, a user named blowtorch gave the tip at the following forum.

Disable Comment Autocompletion

2009-06-03T06:18:00.000-07:00

There are times when Vim's autocompletion of comments gets in my way more than it helps me. Fortunately, disabling comment autocomplete is easy. Just add the following to your vimrc.

au FileType * setl fo-=cro

Snippit Support

2009-06-02T06:14:00.000-07:00

Next time someone who uses TextMate starts blabbering on about how awesome snippits are, politely remind them that Vim supports snippits as well. You can download the snippitsEmu plugin here, and it works quite well. For those unfamilar with snippits, they allow tab-style completion of boilerplate code. For example, you might type class, hit tab, and then a template for a class will be expanded based on the current filetype Vim is set to.

Update: Several readers have cited snipMate as a preferred alternative to snippitsEmu. Thanks guys!

Easier Command Line Editing

2009-06-01T11:11:00.000-07:00

Assuming you're using the bash shell, the following can be helpful when composing long command lines.

Start typing on the command line and then type Ctrl-x Ctrl-e, it should drop you into your system's default editor (hopefully Vim) and allow you to edit the command line from there. Once finished, save the command line, and bash will run the command.

Vim Cookbook

2009-05-18T10:55:00.000-07:00

Run Paint Run Run has contacted me to share a Vim Cookbook he has been working on. It's a creative commons work, and although it's a work in progress, it appears that it's already chock full of useful information. The cookbook is forumulated in a Problem/Solution type format, and I highly recommend giving it a look.

Vim Recipes - Free cookbook for the Vim text editor

Vim Sugar

2009-04-29T07:31:00.000-07:00

Chris Sutter writes:

I have a script and mapping in my ~/.vimrc:

function! CheckForShebang()

   if (match( getline(1) , '^\#!') == 0)

       map <F5> :!./%<CR>

   else

       unmap <F%>

   end

endfunction

map <F5> :call CheckForShebang()

This way, if i'm editing a script with a shebang at the top and i hit <F5>, it maps <F5> to run the script (if not, <F5> is unmapped, so that it doesn't keep checking if I hit it again). I always found myself mapping <F5> by hand to run the current script while i was editting/debugging and I'd frequently lose track of whether I had mapped it or not. You could, of course, replace <F5> with your favorite run/compile/debug/etc key, it just happens to be my standard (from my QBasic days hehe).

Thanks for the tip Chris!

i_Ctrl-O

2009-04-15T07:30:00.000-07:00

Derek Wyatt shared this in a recent comment, and I thought it deserved it's own tip.

If you're in insert mode, and you hit ctrl-o, Vim will accept one normal mode command and then return you to insert mode. Two examples given showed some typical usage:

<C-o>ma - Mark the current position and then keep typing.

<C-o>gql - Format the current line and keep typing

A final blurb from the comment:

"The next type you do <Esc>(thing)a you might remember that you could have done that with <C-o>".

Thanks Derek!

Set Hidden

2009-04-14T08:36:00.000-07:00

If you've ever tried to type :only and had Vim refuse to hide existing buffers because they contain changes, you can use :set hidden to override this behavior. Just remember to keep the possibility of hidden modified buffers in mind when you're doing a :q!.

Yank S-Exp

2009-04-13T06:41:00.001-07:00

If you're hacking a Lisp dialect in Vim, you can do type ya( to yank the current s-exp into the default buffer.

Pull Into Ex

2009-04-10T12:57:00.000-07:00

If you position your cursor over a given word and type :<ctrl-r><ctrl-w> it will pull the value into your current ex mode command line. This is great for yanking long values into substitutions among other things.

Thanks to Nate for the tip!

bashreduce

2009-04-08T08:15:00.000-07:00

I stumbled across this project recently. It's a program that allows you to apply standard shell tools in a map reduce style fashion. Large memory hungry tasks like sorting can be distributed across machines to maximize throughput. As a bonus, it's written in bash, so it's highly portable and works with a combination of vanilla shell utilities and ssh shared-key authentication.

The bashreduce project.

Insert Mode Shortcuts

2009-04-08T08:02:00.001-07:00

Here are some handy shortcuts that you can utilize while you're in insert mode.

ctrl-t - adjust current line one indent right
ctrl-d - adjust current line one indent left
ctrl-w - backspace over a word
ctrl-u - delete to beginning of indent

Why Functional Programming Matters

2009-04-06T06:00:00.000-07:00

I'm always trying to sharpen my skills as a programmer. One approach I've been using to become a better programmer is to learn as many development methodologies as possible. In the past few years, I've become a big fan of functional programming. The basic idea behind functional programming is to compose your programs using functions that return a single value and avoid side effects whenever possible. A side effect is an action that is not required for a function to do it's work. An example of a function with a side effect would be:

function sum(a, b) {
print "a + b = " + (a + b)
return a + b
}

In this case, the print statement wouldn't be required to accurately calculate the sum, so it would be considered a side effect. A pure functional language prohibits side effects altogether; although, most functional languages allow some level of impurity for convenience.

Another common feature of functional programming is the use of higher order functions. Higher order functions are functions that take functions as their arguments; thereby, providing an additional level of abstraction. An example of a higher order function included in most modern languages would be the map function.

function square(x) { return x * x }
numbers = [1, 2, 3, 4, 5]
squares = map(square, numbers)
print squares
[1, 4, 9, 16, 25]

Higher order functions can typically take anonymous functions as their arguments as well leading to increased flexibility.

I can already hear you groaning as you read this article and saying, "yeah yeah, my language can do all that too... what's the point?" Well, in the typical zen fashion of functional languages, it's not always what you can do that matters; rather it's what you can't do. A striking difference between a number of functional languages and their imperative counterparts is how mutability is handled.

A number of functional languages such as Haskell, Erlang, and Clojure address the majority of their built-in types as immutable. This means that once a value is assigned to a local variable, it cannot be changed. At face value, this may seem like a huge disadvantage and might even lead one to believe that certain types of programs might be impossible to write. The truth is that any imperative program can be rewritten in a functional style but doing so requires the adoption of a new set of tools. Specifically, recursion must be adopted in lieu of traditional iteration. Things like closures can be used to simulate state, and objects are generally thrown by the wayside.

At this point, the resounding question in your mind is probably, "why bother?" Well, fortunately there's a very strong reason behind all this shifting of methodology, and that's concurrency. Anybody that's written a non-trivial multi-threaded program in an imperative language has dealt with the difficult issues of synchronization, locking, and sharing of state. The larger and more complex the program, the more difficult it becomes to avoid subtle errors and race conditions. For most programmers writing traditional multi-threaded applications, there are more things that can go wrong than right.

Functional programs that operate on immutable data don't have to deal with any of these issues. Since nothing is shared, there's no potential for race conditions, multiple threads stomping on one another's data, or any of the other trappings one might traditionally succumb to. Freeing the programmer from worrying about such things allows focus to be shifted to solving the actual problem at hand instead of dealing with the fine grained details of threading semantics.

Why should you care about threading? I believe the introduction to Java Concurrency in Practice puts it well when they say, "For the past 30 years, computer performance has been driven by Moore's Law; from now on, it will be driven by Amdahl's Law." Basically, processors aren't getting any faster. For many years, programmers have written code under the assumption that performance wasn't an issue because the next generation of processors would pick up the slack. We've reached the point where we'll never be able to assume this again. From this point on, things will become increasingly parallel, which means that learning to work with multi-core machines will become an increasingly marketable skill.

Traditionally relegated to academia, theorem proving, and compiler writing, functional languages are finally becoming mainstream by filling the multi-core niche. Even if you don't adopt a functional language for your day job, taking the time to learn a different method of problem solving will make you a better programmer and provide valuable techniques you can use in your day to day work.

This being said, there are some really nice languages out there to play around with. I will briefly highlight a handful of them for your perusal. Please take note, that not all of these adhere explicitly to the immutable state share nothing model previously mentioned; although, most provide exceptional facilities for multi-core programming.

Clojure - A modern Lisp running on the JVM. Clojure throws out all the cruft of old world Lisp and provides a lean and mean core with immutable data structures. One of Clojure's core features is excellent concurrency performance, and it also provides seamless access to Java libraries whenever desired.

Scala - Adpoted by Twitter to solve their initial concurrency issues that Ruby could not handle, Scala runs on the JVM, which makes deployment a breeze and provides a multi-paradigm approach to development.

Erlang - Initially developed as a proprietary language by Ericcson, Erlang was open sourced some years back. Erlang makes use of immutable state and sends data back and forth between managed processes using a built-in messaging system. The process model allows code to be seamlessly distributed across several cores, servers, or networks. Ericcson has successfully used Erlang to manage their telco switching on massive networks for many years.

Haskell - A purely functional language with an advanced type system. Haskell provides a robust feature set and an extremely advanced compiler. The ability to introduce arbitrary operators and a non-standard syntax can make Haskell intimidating at first glance, but it's concurrency peformance rivals any other language. Notable projects written in Haskell include the Xmonad window manager and Pugs, a Perl 6 compiler.

OCaml - Numerous wins in the ICFP helped OCaml gain initial notoriety. Native code compilers allow OCaml programs to run at blazing speeds, and a sophisticated type system provides both safety and flexibility.

F# - Developed by Microsoft Research, F# is a variant of ML with a core that is similar to OCaml. It runs on .Net and will be a fully supported language in the .NET Framework and Visual Studio ecosystem as part of Visual Studio 2010.

PLT Scheme - A functional language with a history in academia. The ubiquitious MIT book, how to design programs, uses PLT as it's host language. Excellent documentation makes PLT a great way to cut your teeth on functional programming, and it's concurrency features are actually pretty good as well. Threading in PLT is based on the mechanism used in Concurrent ML.

New Lisp - Although including the word "New" in the name of any product might not be the best idea, New Lisp fills a nice niche in the scripted functional language domain. It seems to be at least partially inspired by Paul Graham's Arc, and it provides a good number of modern features out of the box.

SBCL - One of the de-facto standard Common Lisp implementations. I haven't done any concurrency stuff in Lisp, but I do know that SBCL provides a high quality Lisp implementation for your general Lisp-ing needs. If SBCL doesn't meet your needs, Clisp is another very solid Lisp distribution.

Javascript - The ubiquitous Javascript language now has a JVM port and runs everywhere. It's one of the most widely deployed programming languages on earth and allows the application of higher order functions, lambdas, closures, currying, etc. Who would've thought there was a functional language right under your nose?

Goodbye Daily Vim, Hello Emacs

2009-04-01T07:42:00.000-07:00

After some careful consideration, I've come to realize that it's time to switch editors. Vim has been a good friend, but like an old horse with a broken leg, it's time to put it down. A few days ago, a strange thing happened. Richard Stallman caught wind of this blog and sent me a DMCA takedown notice for documenting patented proprietary Emacs features (copy and paste). I tried to explain that these features were part of Vim as well, but he insisted that Emacs had prior art (implemented in 1953) and that the blog must be taken down at once. Determined to fight back, I decided to take a hard look at the Emacs internals to find some hidden weakness. After days of wanding through the Elisp forest, it happened... I fell in LOVE! Who would've thought that I could send email, surf the web, and play tetris all inside of my text editor? ZOMFG! I'm sorry folks, but if I would've realized what we've been missing, I wouldn't have wasted your time with all these silly Vim tips. This being said, I'll be shutting down this blog in the next 24 hours and dedicating my life to the Church of Emacs. I feel so seriously about this that I'm quitting my job here at Grooveshark and focusing my professional career on writing Emacs kernel modules and improving Emacs boot time. To any earthings that might be reading this, I've enjoyed my time on your planet, but the spaceship has landed, and I must return home. Farewell.

Windows Key Re-maps

2009-03-31T09:35:00.000-07:00

On Windows, Vim has slightly different behavior for a few basic keys. Namely, ctrl-v, ctrl-x, and ctrl-z are re-mapped to make them more familiar to Windows users. Ctrl-v, which is probably the most widely used of these, is re-mapped to ctrl-q. To get the equivalent of a ctrl-z (background process), you can issue the :suspend ex command. I don't believe there are re-mappings for ctrl-a (add) and ctrl-x (subtract); although, you can probably override them in mswin.vim.

Survival Hacks

2009-03-31T07:20:00.000-07:00

Many years back when I was first starting to get savvy with Linux, a co-worker approached me with a problem. He had yanked the harddrive out of his old Linux router and placed it in a different machine. The old machine had on-board ethernet and used a different driver than the new machine's PCI ethernet card. His only other computer was a laptop, which was currently offline due to the router issue. Thinking it would be an easy job, I downloaded a binary copy of the PCI driver and copied it onto a floppy at work. When I got to his house, I realized there was a bigger issue. My friend didn't have a monitor of any sort for the machine we'd be working on. We could have just given up and borrowed one from work the next day, but we decided to see how far we could get without one. We hooked up a keyboard and booted the machine waiting a few extra minutes to be sure we had a login prompt. From there, we very carefully logged in as root and mounted the floppy. The light on the floppy drive gave us a good indication that we were good so far. Not being able to remember the name of the driver forced me to do a glob copy based on the file extension to the /tmp directory, but again, the light on the floppy drive showed things were working. From there, we had another problem. We weren't sure if modprobe, the command to load a kernel module, would accept wildcards, so the globbing was no good this time. Still totally blind, I typed the following into the command line:

for I in *.ko; do modprobe ./$I; done

Fingers crossed, I hoped for the best and typed:

ifconfig eth0 192.168.0.1 netmask 255.255.255.0

From there, we plugged in his laptop, and tried to ping the machine. Much to our surprise, it was up and responding. Feeling accomplished, we did an ssh login from there, and got everything setup as it should be. Now, I'm not saying this was totally elite or anything, but it does go to show that a little creative thinking can get you pretty far. Feel free to share your own survival hacks in the comments if you have a similar story.

Out of the box Autocompletion

2009-03-20T04:23:00.000-07:00

Thanks to Chris Sutter for contributing the following tip:

(The following applies to versions of vim higher than 7.0)

If you are editing a file in vim which ends with .php, .html, .css, .js, .sql, .rb, or .py, you can type (while in insert mode) ctrl-x followed by ctrl-o and vim's "omnifunc" feature combines with its built-in autocomplete feature to show autocomplete options specific to the corresponding language/markup. You can subsequently press ctrl-n and ctrl-p to browse through this list. In short, vim has autocomplete functionality for all common web development contexts (and probably some others) out of the box. But it's not just autocomplete.

If you are editing php (or, i imagine, ruby/python but i didn't try) and the text on which you are autocompleting is the beginning of a valid (builtin) function name, a small window will open at the top of your vim screen showing the method signature with argument names! No more jumping over to php.net to see if it's (needle, haystack) or (haystack, needle)...

Example:
Edit a file called foo.php, enter insert mode, type

<?php
str_r

Now press ctrl-x ctrl-o and vim shows a box below the cursor containing the following, with the first entry highlighted:

str_repeat( f
str_replace( f
str_rot13( f

The "f"s indicate that each entry is a function. If you had entered $_ and pressed c-x c-o, the results would have been "$_COOKIE", "$_ENV", and so on, labeled with "v" for variable)

The window opened above (since the selection is a function) shows:

str_repeat(string input, int multiplier | string

telling you the full function name, the argument types and names and finally the return type.

Admittedly, the c-x c-o and c-n/c-p stuff is awkward. I imagine you could remap to tab/shift-tab which is more common for autocompletion browsing in unix environments. The SuperTab plugin for vim does this for normal file-wise autocompletion (otherwise done in insert mode with c-n and c-p). It could probably be hacked to incorporate omnifunc stuff, too. If I see anything like that out there, I'll send something about it.

Please let me know if there's anything you think vim can't do and I'll see to ensuring you that, in fact, it can and it's easier than you think!

Vim + Cygwin Improvements

2009-03-17T06:32:00.000-07:00

I've been stuck in a Windows environment at work for the last month or so doing Blackberry development. To try and make things more tolerable, I've been doing most of my work in a Cygwin environment; however, the Cygwin Vim build is sub-optimal compared to the native Windows build. This lead me to try and find a way to use Windows Vim seamlessly from inside Cygwin. The following alias worked out nicely:

[bash-fu borrowed from this tip]

alias vim='VIM=`cygpath -d "$VIM"` HOME=`cygpath -d "$HOME"` "`cygpath -u "$VIM"`/vim72/vim.exe"'

In this case, the $VIM environment variable is initially set to C:\Program Files\Vim. It's also important to change the vim72 version number to whatever matches your install.

The second thing I did, which is making life a lot easier, is switch to using Console2 as a replacement for the standard Windows cmd.exe. The combo of Console2, Cygwin, and a decent Vim build is a good bet if you're committed to Windows for whatever reason.

Change Last, First to First Last

2009-03-10T04:59:00.000-07:00

Here's a tip borrowed from the Vim help file. Say that you have a list of names like:

Doe, John
Smith, Peter

and you want to change that to:

John Doe
Peter Smith

You can use the following substitute pattern to easily do so:

:%s/$[^,]*$, $.*$/\2 \1/

Basically, you're capturing zero or more NOT commas followed by a comma and space and then capturing zero or more of anything. The comma and space are outside the parens, so they're not stored. The parens store the captured groups in the special variables \1, \2, \3, \N from left to right, so the replacement pattern is substituting in the groups in the reverse order they were captured.

Tab Buffer Browsing

2009-03-09T10:08:00.000-07:00

Using the following mappings in normal mode provides a convenient way to easily switch between the next and previous buffers.

nmap <tab> :bn<cr>
nmap <s-tab> :bp<cr>

Thanks to Chris for the tip!

Twistem.FM

2009-02-09T07:20:00.000-08:00

Ok, this is not Vim related, but it is something I'm very excited about. Here at Grooveshark, the startup company I work at, we've just launched a new service. It's called Twisten (a play on tweet + listen), and it uses the Twitter API to aggregate tweets about music. For any song it can identify, it adds the tweet to a public timeline and allows you to play the song.

My primary role on the team was designing the parsers which identify meaningful bits of information inside a tweet and then converting them to actual songs. Fun stuff!

If you're a fan of Twitter (or music), check out Twisten.FM.

Autocommands

2009-02-09T07:09:00.000-08:00

You can add an auto command to your vimrc to have it automatically executed when a certain type of file is loaded. As an example, I use the following to convert tabs to spaces when a PHP file is loaded.

auto BufReadPost *.php retab!

See :help auto for the full info.

Editor Comparison

2009-02-04T04:52:00.000-08:00

A friend sent this to me, and I thought it was pretty funny. I'm not sure of the original source. Thanks Nate!

UPDATE: The comic is from this blog. Good stuff!

Ignore the Modified Flag

2009-01-27T06:45:00.001-08:00

There are times when I'm working on a temporary buffer, and I want to do something like a `gf' (go to file), but Vim insists that the buffer is modified and refuses to abandon the file. You can get around this by telling Vim the file isn't modified.

:set hidden

This effectively makes Vim treat the file like it's already saved. Please avoid using this for any production files as it can make Vim think that the file on disk is different than it actually is.

Make Windows Equal Height

2009-01-27T06:09:00.000-08:00

If you have a bunch of split windows of disproportionate sizes, you can make them all equal by doing a `ctrl-w =' in normal mode.

Converting Tabs to Spaces

2009-01-20T07:48:00.000-08:00

Here's a quick way to convert a tab-stopped file to a space-formatted file.

:set expandtab
:retab!

Last Changed Text

2009-01-15T06:47:00.000-08:00

Here are two helpful commands to get to the last changed or yanked text.

`[ - First character of previously changed or yanked text
`] - Last character of previously changed or yanked text

Extending History

2009-01-14T07:29:00.000-08:00

You can allow Vim to store more history than the default (last 20 commands) by setting history as follows.

:set history=N (where N is how much history you want to keep)

Delete to End of Page

2009-01-13T08:33:00.000-08:00

Typing `dL' in normal mode will delete to the end of the current page. In other words, everything visible to the bottom of the window.

Remap Backtick

2009-01-12T05:00:00.000-08:00

I find it convenient to remap the backtick key "`" to single-quote "'". Functionally, they are very similar. Backtick takes you to an exact mark location while single-quote simply takes you to the beginning of the marked line. I don't use the single-quote functionality much, and it's much easier to reach than backtick, so the following mapping saves some finger stretching.

nnoremap ' `
nnoremap ` '

Reformat a Paragraph

2009-01-10T05:47:00.000-08:00

Say you have the following text:

> someone said
> > someone else said
> > > long quoted message
> > blah blah
> blah

Place the cursor on the first line and do `gqip'. I often use this combo to conveniently reformat paragraphs.

Modelines

2009-01-09T04:22:00.000-08:00

Vim allows you to insert modelines to specify options you'd like for a specific file. For example, you could have a perl script as follows:

#!/usr/bin/perl
# vim: set expandtab:
use strict;

This would tell Vim to expand tabs in the current file. See :help modeline for more info.

Removing Ctrl-M

2009-01-08T04:16:00.000-08:00

There are quite a few ways of doing this, but a quick way to remove ^M scattered around your file is as follows:

:%s/C-vC-m//g

Where C-v is Ctrl-v and C-m is Ctrl-m.

Command on All Windows

2009-01-07T04:13:00.000-08:00

Here's a neat trick. If you want to execute an ex command on all windows, you can do the following:

:windo command

so...

:windo %s/foo/bar/g would find and replace foo with bar in all windows.

Only RSS Vim Tips

2009-01-05T13:51:00.000-08:00

For those of you that would prefer to exclude any tips from this blog that aren't directly related to Vim from your RSS, I have an easy solution. Blogger allows feed URLs to be filtered based on tags. I only use the vim tag on posts directly related to Vim, so the following RSS URL should be a convenient solution.

http://dailyvim.blogspot.com/feeds/posts/default/-/vim

Value Under Cursor #2

2008-12-12T10:11:00.001-08:00

Expanding on a previous tip. Here are some methods for figuring out the value of a given character.

1) Using gf - place the character under a character and hit ga in normal mode to obtain it's ascii value.

2) Using g8 - same as above but applies to UTF-8 characters.

3) :set list - toggles displaying unprintable characters.

4) pipe into the shell command od -c

5) type the :ascii ex command to display a characters ascii value

6) use cat -vET filename

Setting the Filetype

2008-12-12T08:00:00.000-08:00

Vim normally sets the current filetype automatically and very accurately at that. In some cases though, such as when you're starting a file from scratch, it doesn't know the filetype. In these cases, you can set the filetype manually.

:set filetype=perl
:set filetype=php
:set filetype=python

etc...

Ubuntu: Downgrading X.org

2008-12-11T06:46:00.000-08:00

First things first, if you use multiple monitors and you're thinking about upgrading to Ubuntu 8.10 (Intrepid), I would recommend holding off. A good number of users, myself included, have experienced a very annoying bug where the mouse spontaneously loses it's ability to click. The only way to regain mouse support is to kill X with ctrl-alt-backspace (ugh). I've been able to faithfully reproduce the bug by doing the following:

* Enable Xinerama in xorg.conf
* Open firefox fullscreen on both monitors
* Rapidly move the mouse between monitors

It's worth noting that this bug has nothing to do with what window manager you're using. I've experienced it under Gnome, AwesomeWM, and Xmonad. The bad news is that even though a lot of people are complaining about it, the bug has not been fixed. As of right now, the only reliable method to regain workstation stability seems to be downgrading X.org back to the Hardy packages. To assist anyone who might be Google'ing this issue, here are the instructions for doing so.

Log into a text console as root and shut down X with '/etc/init.d/gdm stop'.

Add the following to your /etc/apt/sources.list:

deb http://us.archive.ubuntu.com/ubuntu hardy main
deb http://us.archive.ubuntu.com/ubuntu hardy-updates main
deb http://us.archive.ubuntu.com/ubuntu hardy-security main

Run apt-get update.

Purge all the packages you can by doing the following:

cd /var/lib/dpkg/info/
dpkg --purge `ls *xorg*.list | sed s/.list// `

Some of these will fail to purge due to dependency issues. That's OK. Continue with the instructions.

Reinstall the packages from the Hardy repo:

apt-get --reinstall install x11-common/hardy xorg/hardy xserver-xorg/hardy xserver-xorg-core/hardy xserver-xorg-input-kbd/hardy xserver-xorg-input-mouse/hardy

Note that if you're using a stock Ubuntu video driver such as the Matrox driver you will need to include it in the list as well (xserver-xorg-video-mga/hardy). I use the third-party Nvidia driver, so it wasn't necessary to include it in the list.

After this, you can start X with "/etc/init.d/gdm start" and hopefully login to a working desktop. The final step is to go into synaptic and lock the reinstalled packages to avoid the upgrade manager from nagging.

Thanks to Nelson for providing these instructions, which I've modified slightly for presentation here.

PHP: Invoking a method with Map

2008-12-05T09:15:00.000-08:00

Ever since I learned the basics of functional programming, I've been a fan of the map function. In the right context, it can be an elegant solution for array transformation. Of course, like anything, it can be misused. Using PHP's map, it's non-obvious how to make it invoke an instance method rather than a function. The following example illustrates how this can be accomplished.


class M
{
    function double($a) {
        return $a * 2;
    }
}

$m    = new M;
$list = array(1, 2, 3);
$list = array_map(array($m, 'double'), $list);
print_r($list);

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
)

Find Dot Files

2008-12-02T07:08:00.000-08:00

Sometimes I forget the name of a particular config file but know it's stored as a dot file in my home directory. The following one-liner will non-recursively display any regular file begining with a dot.

find . -maxdepth 1 -type f -name '.*'

Find does it again. ;-)

Right = Left

2008-12-02T05:57:00.000-08:00

Here's a tip that's mostly for fun. Open up Vim and type :set rightleft.

This changes display orientation to right-to-left. This can be useful for editing Hebrew and Arabic or just for freaking people out.

AwesomeWM

2008-11-26T08:38:00.000-08:00

I've used a lot of window managers and desktop environments over the years (Gnome, KDE, Window Maker, Blackbox, Fluxbox, Enlightenment, XFCE, etc...). The last few years, I've lost a lot of motivation to experiment and stuck with the OS default (Gnome/Metacity in my case). Recently though, I've been increasingly trying to avoid ever touching the mouse. This is partially due to wrist issues and partially just to try and be more efficient. The quest for a mouse free lifestyle lead me to find the aptly named Awesome Window Manager.

If you're like me and have used many window manager, you're probably groaning right now and saying, "what makes Awesome any different from my current window manager?" Well, quite a few things actually. For one, Awesome is a tiling window manager. This means that if you open three terminal windows on the same screen, the WM will neatly organize them on the screen in an intelligent fashion. If you don't like the tile layout, you can switch layouts with a keystroke. If you want a certain application to fall outside of the default tiled layout, you can set it to float, and it will behave like it would in any other window manager.

While tiling is nice, it's not the only thing that makes Awesome unique. Awesome also avoids the traditional concept of virtual desktops or workspaces in favor of a tagging mechanism. Tags allow you to assign applications to logical groups in which they will appear together. An application can be bound to any number of tags. Even better, tags allow you to assign rules to newly opened applications, so I can say, "Firefox will open on the `Firefox' tab in floating mode on my 2nd monitor". You can also assign a default layout and number of columns to a given tab for tiling. Last but not least, each monitor can have it's own tagset giving you the equivalent of an independent session per monitor.

This is all good and well, but what does it have to do with getting around with the keyboard? Well, quite a lot actually. Awesome allows you to setup keybindings to navigate between tabs, send applications to a given tab, switch between applications on a given tab, resize windows, rotate windows within the tileset, jump between monitors, etc. All this is done inside of your awesomerc file, and the syntax is very straightforward. In my custom configuration, I've setup Awesome to respect keybindings very similar to Vim, so I can jump between monitors and windows using a combination of my meta key (windows key), a modifier (alt), and H, J, K, and L. As a bonus, it also happens to be extremely fast with performance in the same class as fluxbox and it's cousins.

A final feature that I've come to absolutely love is it's widget support. There's a user configurable statusbar that by default contains your current tagset listing and a small layout diagram. The rest of the statusbar is essentially open for whatever you want to add. All an application has to do to update the statusbar is write to standard output, so I've constructed a series of shell scripts to show the current time, CPU usage, memory usage, active users, and active streams at Grooveshark. All of these are basically one-liners. Here's my clock for the sake of example:


#!/bin/sh
while true
do
    echo "0 widget_tell mystatusbar clock text " \
         "`date +"%A %B %d, %Y %l:%M %p"`" | awesome-client
    sleep 1
done

In case I missed anything, here's the laundry list of features from the Awesome website.

* Very stable, fast, small and simple;

* Only window manager using asynchronous XCB library instead of the old synchronous Xlib: make awesome faster than any other window manager;

* Very well documented source code and API;

* No mouse needed: everything can be performed with keyboard;

* Real multihead support (XRandR, Xinerama or Zaphod mode);

* Implement many Freedesktop standards: EWMH, XDG Base Directory, XEmbed, System Tray;

* Some real transparency support (using Composite extension and xcompmgr);

* Doesn't distinguish between layers: there is no floating or tiled layer;

* Whether or not the clients of currently selected tag(s) are in tiled layout, you can rearrange them on the fly. Popup and fixed-size windows are automatically floating.

* Layout handling: automatically manage your windows placement according to the chosen policy for each tag;

* Use tags instead of workspaces: allow to place clients on several tags, and display several tags at the same time;

* A lot of Lua extensions to add features: dynamic tagging, widget feeding, tabs, …;

* D-Bus support;

* And more.

And of course a screenshot is worth a thousand words.

And Finally, The AwesomeWM Website.

[edit]
As requested, here's a copy of my awesomerc. Note that I'm using version 2.3.4.

Reload VIMRC

2008-11-25T21:27:00.001-08:00

You can quickly and easily reload your vimrc with the following command.

:source $MYVIMRC

If you want to know what your current vimrc is, just do the following.

:echo $MYVIMRC

Tabs

2008-11-25T07:14:00.000-08:00

It took tabs a while to grow on me when using Vim. This is mainly due to the flexibility that buffers and split windows provide; however, once I realized tabs could act as a convenient way of grouping split windows, I was sold. There's nothing complicated or confusing about using tabs, but a few mappings will make your life easier. Add the following to your vimrc.

let mapleader = ","
map <leader>tt :tabnew<cr>
map <leader>tc :tabclose<cr>
map <leader>tm :tabmove
map <leader>tn :tabnext<cr>
map <leader>tp :tabprevious<cr>

I've already been called a n00b once on this blog for not seeing the value of the comma motion (repeat latest f, t, F or T in opposite direction). If you use it regularly, you'll obviously want to choose a different map leader.

Now that your mappings are setup, using tabs should be quick and intuitive.

* Press ,tt to open a new tab
* Press ,tc to close the current tab
* Press ,tm [number] to move to tab [number]
* Press ,tn to move to the next tab
* Press ,tp to move to the previous tab

In standard Vim, the tab list will appear at the top of your editing window. Gvim provides the industry standard GUI tabs. Obviously there are more tab commands available, but these basics should get you pretty far.

Using a Mapleader

2008-11-21T07:54:00.000-08:00

As you have probably realized, keyboard real estate in Vim is pretty heavily occupied in normal mode. Specifically, just about every key is already bound to a command. Luckily, Vim provides a facility to define additional mappings on these keys. It's called a mapleader, and it's easy to setup.

First you need to define what key you want your mapleader to be. I prefer comma because it's (in my daily usage) unused, and it's easy to reach. Add the following to your vimrc.

let mapleader = ","

Now that mapleader is defined, you can use it for custom mappings at will.

:map <leader>n :new<cr>

Press `,' then `n' in normal mode, and it splits to a new window.

:map <leader>i I

Press `,' then `i' in normal mode, and it puts you into insert mode on the first character of the current line.

These usage examples are slightly obtuse, so I'll be showing how to incorporate using a mapleader into tab management in an upcoming post.

Share a Screen Session

2008-11-20T08:51:00.001-08:00

It's possible for two users to share a screen session. This is particularly useful if multiple people want to monitor a long running task, and it's easy to do.

user #1:

screen -R longbuild

user #2:

screen -x -R longbuild

The -x flag tells screen to allow you to attach to an already attached session. This is also good for crazy stuff like a collaborative Vim session (if you're into that sort of thing).

Vim to Postscript

2008-10-20T04:51:00.000-07:00

Thanks to Karl for the following tip:

Here's a little Vim trick that might be of interest. If you're on a non-Windows machine, you can make the Vim hardcopy command print to a postscript file instead of a real printer. Try issue the following:

:hardcopy > file.ps

You'll get a postscript output of the file you're currently editing.
From there you can view the postscript file with gv or convert it to a pdf with ps2pdf.

MySQL DBD in Activestate

2008-10-16T18:48:00.000-07:00

I'm currently doing some consulting work to bridge the gap between Oracle and MySQL. Being in a Windows environment, I'm using the Activestate Perl distribution. Fortunately, it includes a nice ODBC module for connecting to Oracle out of the box. The bad news is, it doesn't contain a MySQL module. Luckily, I found a third party host that does provide the module. The following ppm (Perl Package Manager) one-liner takes care of the issue.

C:\>ppm install http://cpan.uwinnipeg.ca/PPMPackages/10xx/DBD-mysql.ppd

The Golden Rules of Recursion

2008-10-16T13:26:00.000-07:00

1) never iterate
2) always follow the first rule ;-)

Where I've Been

2008-10-16T11:57:00.000-07:00

I've come to realize that my post per day ratio here at Daily Vim is a good measure of how busy I am in my daily life. To be more specific, my workload is inversely proportional to my blogging habits, but please don't think I've forgotten about this blog. I haven't, and the posting will continue. Lately though besides being buried under a mountain of side-work, I've been working diligently alongside the rest of the Grooveshark team to facilitate one of our largest launches in recent memory.

Today, all that hard work came to fruition, and I'm happy to announce that our streaming service, Grooveshark Lite, has been expanded with the addition of the following features.

Shared Playlists

Blog Widget

Improved Social Features (follow users, find similar users, etc...)

Music Upload Client

Autoplay Improvements

More Reliable Streaming

If you scroll down this page, you can see an example of the blog widget in action. The widget builder page allows you to embed a playlist or song of your choosing into any website, size it appropriately, and drop it in. I'll be updating my blog playlist frequently as a means to passively share music that I enjoy.

Back on the topic of Daily Vim, now that things are settling down a bit, I'm hoping to post more often, as I have some cool tips I'm looking forward to sharing.

Why Ruby is My Favorite Language

2008-10-09T05:00:00.000-07:00

I started programming seriously roughly ten years ago. I was working in the call center of an ISP, and there was a need for a reseller tracking application. I was attending the local community college at the time, and had been indoctrinated into the world of computer programming trhough what amounted to vocational training in Visual Basic and Microsoft Access. Fortunately, the ISP was a Linux shop, and a few employees were nice enough to introduce me to the basic philosophy of Linux and assist in learning some rudimentary shell commands.

One of these employees was a Perl hacker, and he assisted in convincing the company to form a small team of three programmers to tackle the programming job. I was lucky enough to be chosen for the position, and to be frank, after having spent a few months in the call center, I would have considered janitorial duties a promotion. The only problem was that I didn't know Perl. I quickly ran to the nearest bookstore, grabbed a copy of Learning Perl, and set to work learning the language. A week later, I was neck deep in the project and thankfully had an experienced programmer to lead me through my first big job. The project was a success, and the team became a permanent fixture at the company.

What impressed me so much about Perl was the succintness, mneumonic friendliness, and consistency of the language. After a few weeks of intense study, I could perform the majority of my daily programming tasks from memory and rarely needed to consult a reference.

A year or so later, PHP hit the scene. With the huge buzz surrounding the language, I figured there had to be something really groundbreaking going on. The team I was working on chose to build a large project in PHP, and once again, I set out in earnest to learn the language. This time, things weren't so easy. While Perl had "sunk in" right away, PHP lacked the natural abstraction I had come to love about Perl. As an example, I didn't understand why PHP needed sixteen sort methods (sort, arsort, asort, krsort, ksort, natsort, natcasesort, rsort, usort, array_multisort, uasort, uksort, dbx_sort, imap_sort, ldap_sort, yaz_sort) while Perl only needed one. The database methods lacked the wonderful platform independence of DBI, and a lot of other things felt redundant. Mostly though, I disliked the way the language encouraged mixing interface with your implementation. At the time, the PHP website frequently featured examples interpsersing functions and HTML and even touted this ability as a "language feature".

Progressing through my courses, I ended up taking a class on object oriented design. I learned about the model view controller architectural pattern and immediately saw it's advantages as a design strategy. I learned the basics of object oriented programming with Perl, but I was dissatisfied with the way it was implemented. I spent a considerable amount of effort learning Java and later Python. I found both languages to be "good enough" in the way they possessed a healthy amount of easily accessible OOP goodness, but I missed the fluidity of programming in Perl and neither ever became a "favorite".

At this point I was working at an environmental laboratory, and I was given complete freedom to use whatever technology I wanted to solve the problems at hand. I was tasked with writing a data analysis and computation software for an ICAP (Inductively Coupled Argon Plasma Spectrometer), and I was again at a crossroads. An article on Slashdot had drawn my attention to the Ruby programming language, and I found an excellent book that was freely available online. Reading the introductory walkthrough section, I was immediately impressed by the fact that literally everything in the language was an object. The core language was incredibly consistent, concise, and well documented with absolutely no cruft. All of the wonderful Perl idioms I'd come to know and love were right there at my fingertips; albiet, in a more readable fashion. I was sold.

I learned the language and developed the project simultaneously. This was long before Rails was even a whisper in the programming world, so I rolled my own MVC style framework containing a presentation layer that used a combination of XML, eruby templates, and LaTeX. This made it easy for the app to generate both HTML and PDF documents on a whim. The development cycle was fast, the project was finished ahead of time, and everybody loved the final product. Later I wrote a C extension for Ruby to easily access the Win32 serial port allowing an archaic lab instrument to dump data straight to an OpenOffice spreadsheet. I'd never considered writing a C extension to any other language, but again, Ruby made it easy.

Since then, Ruby on Rails has rolled onto the scene and has allowed me to develop projects in which I would have needed a team in the past. MVC is the core paradigm and being able to use my favorite language alongside my favorite architectural pattern is nothing short of a godsend as a web developer. I've used Rails to develop web applications on the fast track and have brought in a nice supplementary income doing so. Best of all, I feel good about the final product when writing a Rails app knowing I'm developing in a standardized way where another programmer will be able to come along later and easily maintain the work I've done. There are MVC frameworks for PHP, but there's still no de facto standard way to roll a PHP app. This makes every PHP app a "special surprise" when you look under the hood. Sadly, the surprise isn't always pleasant.

I'm not saying you can't write good code in PHP. Actually, working at Grooveshark has shown me that it's possible to write extremely clean code in PHP, but I still run to the PHP manual several times a day to lookup one of it's 3000+ core method signatures.

I'm acutely aware that languages are like religions among developers and that everyone has their favorite for one reason or another. I'm also certain there are people out there that would disagree with some of the arguments I've made here. Arguments aside, if you're looking for a new language to learn, and you haven't tried Ruby, take a look, and I think you'll be pleasantly surprised at all that it has to offer.

Vimperator

2008-10-01T06:19:00.000-07:00

There's a plugin for firefox which allows firefox to behave more like Vim. Some of the features include:

* Vim-like keybindings (h,j,k,l,gg,G,0,$,ZZ,,etc.)
* Ex commands (:quit, :open www.foo.com, ...)
* Hit-a-hint like navigation of links (start with 'f' to follow a link)
* Vim-like statusline with a wget-like progress bar
* Macros to replay key strokes

etc...

The author really threw in the kitchen sink. I've seen my co-worker using this, and it's SUPER cool.

Vimperator Plugin

SSH Remote Connections via Config

2008-09-30T04:08:00.000-07:00

Thorsten has contributed the following ssh tip. Thanks Thorsten!

You wrote about ssh connects via gnome terminal:

http://dailyvim.blogspot.com/2008/09/gnome-terminal-tips.html

I'm using the config file of ssh to achieve the same goal:

just put the file "config" in your .ssh directory (chmod 600) with the
following lines:

host mysshhost
user root
identityfile /root/.ssh/my_ssh_key.ssh
port 34021
hostname 127.0.0.1
localforward 10100 localhost:10100
ForwardX11 yes

then back at the command line just try:

myhost:/ # ssh mysshhost

and voila, welcome to your ssh connected system (even the
bash-completion works with the config file, just do a ssh )

Question: Browsing Remote Filesystems

2008-09-29T06:04:00.000-07:00

A Daily Vim reader asks the following question:

Travis, the feature that has me married to Kate (KDE text editor) is the file browser with bookmarks built in. Kate allows users to browse remote filesystems from within the app just like they could browse the local filesystem in a file manager. Furthermore, there is a bookmarks feature where users can bookmark specific directories / files on remote servers. Anythink like those two features in VIM?

Thanks!

Anybody have any ideas on this? I have a few ideas, but I'll wait and see if anybody else has a suggestions first.

Whatprovides

2008-09-25T07:36:00.000-07:00

If you're using a RedHat derivative that utilizes yum as it's package manager, you can use the `whatprovides' command to see what package provides a specific file.

Example:

yum whatprovides /usr/bin/vim

... grab a coffee ...

vim-enhanced.x86_64 1:6.3.046-0.40E.7.cent base
Matched from:
/usr/bin/vim

Debian derivatives provide a similar functionality via the apt-file package.

# sudo apt-get install apt-file
# sudo apt-file update
$ apt-file search /usr/bin/diff
diff: /usr/bin/diff

Unhighlight Current Search

2008-09-19T10:35:00.001-07:00

If you want to un-highlight the currently highlighted search terms, issue the following command.

:noh

Search Register

2008-09-12T05:50:00.000-07:00

You can manually push a value into the search register using the following syntax.

let @/='Some String'

This is particularly nice for script hacking when you want to highlight a group of strings in the current buffer.

Vimgrep Without Object Names

2008-09-12T05:46:00.000-07:00

My friend Chris (Vim user extraordinaire) has contributed the following tip. It looks like it could be quite useful to any Java hackers in the crowd.

I constantly want to use :vimgrep to find usages/references to certain object types in my java code. However, when I :vimgrep for the object name, it (naturally) matches all of the 'import' statements, too. I've known for awhile that there was an idiom in the regex syntax to negate a previous atom (in this case, the 'import' at the beginning of the line) but I've never found a way to phrase it that works. Here it is:

.*ObjectName\&^$import$\@!

This matches any line meeting the following two constraints:
1) contains anything (.*) followed by ObjectName
2) starts (^) with something which isn't 'import' ($import$\@!)

the \@! says, match if the preceding atom does not match here -- since we put ^$import$ this means match when the first thing in the line isn't import.

There may be better ways to do this, but it's the first I've found and I'm using it like crazy now... Enjoy!

Thanks Chris!

Question: Highlight From Insert?

2008-09-12T05:17:00.000-07:00

Iyo writes:

"I offten do some coding in Vim and I miss an feature that will highlight
the word I`m writing in that moment and other same words. (It is mainly
for variables - sometimes I switched letters and afterwards I`m looking
for mistake for a quite long time. The NetBeans IDE has a feature like this.

I know about * but it`s for search in the text. I`m looking for something that work automaticly in insert mode."

Answer:

You can use ctrl-o from inside of insert mode to enter a command, but to me typing ctrl-o * while I'm hammering out some code feels awfully cumbersome. There's also the negative side-effect that * jumps forward, so you'd lose cursor position, which would assuredly interrupt workflow. Instead, I'd just define a simple mapping along the lines of the following.

imap <F2> <Esc>#*A

So, you're inside insert mode, you just typed a word, and you want to match all occurrences. You would simply hit F2, and it would backward match the word nearest the cursor. This has the negative side effect of jumping backwards; thereby, losing cursor position. To compensate, we add a * to jump forward followed by "A" to return to insert mode and insure you're at the end of the line. Obviously, you can substitute any keybinding you want for F2.

This seems to work well on my machine; although, there might be more optimal solutions. If anybody has one, feel free to share.

Got a Question?

2008-09-11T07:17:00.001-07:00

I had a reader of Daily Vim contact me yesterday about the possibility of periodically submitting questions regarding Vim best practices, etc. I told him that I'm very happy to assist in answering questions any Daily Vim readers might have but if I don't know the answer, I'll post the question here anyway, so someone smarter than me can ;-).

So, if you have a question regarding Vim, Linux, scripting or something along those lines, feel free to post them under this thread or email me directly via tinymountain at gmail dot com. I'll post the question and possibly an answer to the blog, and as usual, feedback is welcome.

To kick things off, I have a question of my own. Does anybody know of a Vim plugin or some method to spontaneously highlight every other line of a file? I frequently use Vim as a pager inside of MySQL, and this would be very handy for eyeballing all the values on a specific row.

UPDATE:

I solved this problem thanks in part to an initial suggestion to use syntax highlighting to perform the highlighting. Here's my finished solution. It seems to have issues with language files with pre-existing syntax highlighting, but for it's intended purpose (use within the mysql pager), it works beautifully. Just do "pager /usr/bin/vim -R -" inside the mysql client, add the code to your vimrc, run a query and hit F2.


hi AlternateLine ctermfg=grey ctermbg=darkblue

function! HiLine(lineno)
    let tmpline = escape(getline(a:lineno), '/\[]')
    exec 'syn match AlternateLine /.*' . tmpline . '.*/'
endfunction

function! DoHighlight()
  global /^/if line('.')%2|call HiLine(line('.'))
  normal 1G
endfunction

map <F2> :call DoHighlight()<cr>

Jump to Percent of File

2008-09-11T07:13:00.000-07:00

Sometimes you don't know the exact line you want to go to in a file, but you can infer an approximate percentage. I was browsing a 200 meg logfile with Vim yesterday and guestimated the area of interest was about 10% back from where I was at (85%). You can easily jump to a desired percentage in a file by typing in the percentage followed by a percent symbol.

Jump to 50% of the file:

50%

Easy to remember to say the least ;-)