Buffers
We can think of a buffer as a place inside Vim where a file is loaded. In the following example, I will use a couple of files:

$ cat file1 file2
This is file 1
This is file 2
$ vim file1

This is file 1
~
~
~
~
~
~
~
~
~

To see file2, we use the :e command to load and edit the new file:

~
~
~
~
:e file2 [ENTER]

Hint: you can use TAB to autocomplete file names and commands

This is file 2
~
~
~
~
~
~
~
~
~

Vim is now showing file2, but what happened with file1? It is still there, loaded into the first buffer. We can return to it using the buffer previous command, :bp

This is file 1
~
~
~

What if we want to move to file2? buffer next, :bn. In fact, if you do it twice, you will get file1 again.
This is because buffers are circularly linked. Like this:

 ---------------------------- bn ---------------------------->
file 1 <--bp/bn---> file 2 <---bp/bn---> file 3 <--bp/bn---> ...<---> file N
<------------------------ bp ----------------------------

It is useful to know each buffer’s contents. You can do this with the :buffers command.

~
~
~
~
:buffers
  1 %a   "file1"                    line 1
  2      "file2"                        line 0
  3      "file3"                        line 0
  4      "file4"                        line 0
  5      "file5"                        line 0
  6      "file6"                        line 0

Imagine you are in the third buffer and you want to edit the 45th of a total of 100 files. In this case, you do not really want to use the :bn or :bp approach but the :buffer number command:

~
~
~
~
:buffer 45 [ENTER]

This command sends you to the exact buffer. One restriction to take into account when moving from one buffer to another is that you should save your work before leaving the current buffer. If you do not do it, you will see a message like the one below:

E37: No write since last change (add ! to override)

as when trying to quit Vim without saving.
To override this restriction (if you really want to do it), use a bang: :bn!. The content of the modified buffer will not be lost, it is a just a warning. However, it is a good habit to always save before leaving a buffer.
Every time you edit a file, it is loaded into a buffer even if you do it invoking Vim with several file names. For instance, if you start Vim like this:

vim file1 file2 file3

Vim will load the files into three different buffers (check it out with the :buffers command.

Viewports
A viewport can be imagined as a window inside Vim. Basically Vim splits the visual area into several parts either vertically or horizontally. We can use the :sp (split) or the :vsp (vertical split) with or without a file name. This is what appears after invoking Vim and executing the :sp command:

~
~
~
~
~
~
~
[No Name]                                                     0,0-1          All

~
~
~
~
~
~
[No Name]                                                     0,0-1          All

Pretty cool, isn’t it? You can jump from one viewport to another using Ctrl-w-w (this is, Control-w and then w again). When Vim is showing several viewports, all the actions take place at the specific viewport in which you are working. For instance, if you search a term, the search is limited to that viewport.
You can start Vim with several viewports using the -o and -O flags. The former splits the window horizontally, the latter does it vertically (forgive my use of screenshots but for once I guess they are illustrative :-) ):

$ vim -o make.conf sysctl.list

A viewport can be split again into more viewports. That is nice, but you can end up with something similar to the screenshot below, so do not be too enthusiastic creating viewports ;) :

Of course, in each viewport, the complete buffer list is available. This is a global list for each Vim session. The default layout of the viewports may well not satisfy your needs. In that case you can use the movement commands using uppercase letters preceded by Ctrl-w. These commands move the viewport in which they are applied. For example, if we have two vertical viewports and we are positioned at the left one, typing Ctrl-w L moves the viewport to the right and the right one to the left.

Tabs
Since Vim 7, there is a new way to edit multiple files. Tabs work like in many other applications (e.g. web browsers). To create a new tab, use “:tabnew“. You can use Ctrl-Up and Ctrl-Down to move through the tabs.

I know what you are asking yourself and the answer is yes: every tab has access to the global buffer list and it can be split into several viewports. Thousands of possibilities at hand!

There are a lot of commands to help you dealing with tabs. Some of them are :tabNext, :tabprevious, :tabfirst and :tablast to move through the tabs. :tabclose to close the current tab and :tabs to obtain a list of tabs.

Being efficient
Editing multiple files using buffers, viewports and tabs is OK. Having several files open at the same time, it is easy to move through them, etc. But what if you want to do something for all files at the same time? The family of commands [buf/win/tab]do do the magic. They apply an action to all the files in the list of buffers, viewports or tabs. For example:

~
~
~
~
~
~
~
:bufdo :%s/file/archive/g | w!

The command above replaces all the occurrences of file by archive (do not worry if you do not understand the command, we will visit the search and replace topic in another issue).
Other interesting command:

:bufdo !tar rvf package.tar %

Creates a tar file named package.tar containing all the files loaded into the buffers

Conclusion
Although this has not been an in depth tutorial about buffers, viewports and tabs, it should be sufficient to help you manage your files under Vim efficiently. As a programmer, I find these features extremely useful. I usually have my .h and .c/.cpp files open in two viewports so I can see both the declaration and the definition of the classes at the same time, for example.
Use these features for a while and you will realize how easy and efficient your daily work can become.

Enjoy!

Vim Sheet (IV)

• :e Edit a new file (and load it into a new buffer)
• :bp, :bn Move to the previous/next buffer
• :buffer number Move to the specified buffer
• :buffers, :tabs Show the list of buffers/tabs
• :sp, :vsp Split the current viewport horizontally/vertically
• Ctrl-w w Move to the next window
• Ctrl-w H/J/K/L Move the current viewport in the specified direction
• :tabnew Create a new tab
• Ctrl-Up, Ctrl-Down Move to the next/previous tab
• :tabNext, :tabprevious, :tabfirst, :tablast Movements through the tab list
• :bufdo, :windo, :tabdo action Apply action on all the specified objects

$ pstat -T
6052/12328 files
0M/128M swap space

pstat is part of the FreeBSD’s base system
Enjoy!

This is a sample text

(Bold letters indicate the cursor position as in the previous issues.)

Now type: yw followed by ESC o
As you can expect, you have just yanked a word and opened a new line below the current one. Now, paste the copied text: in command mode, type p

This is a sample text
sample

Easy, right?

You can do the same thing going into Visual mode (pressing v or V). Once you are in this mode, use h, j, k, l to move around and mark the selection area. When you are done, end with y.

The same procedure is used for cutting. Just replace the y command with the d command. What if you want to paste the selection above the current line? Use P when pasting the selection instead of p.
Another shortcut: use yy to yank a whole line (remember you can always use modifiers, so you can do something like 2yy to yank two lines).

Using registers
This has been easy so far. Let us be more efficient. In vim, you can use several registers to put text into.
It is as easy as doing this:"{register}{operation}. For instance, assuming we have already selected some text, we can do: "ry
And the selected text will be put into the r register.

In the following example, the word “bluetooth” is selected.

Everything is better with bluetooth.

Now, type: "ry to copy the text into “r” register.

Everything is better with bluetooth.        ESC o

And now, we paste the text with: "rp

Everything is better with bluetooth.
bluetooth

You can inspect the contents of these registers going into command line mode and typing registers. E.g:

:registers[ENTER]

:registers
--- Registers ---
""   bluetooth
"0   This is a test^JThis is another line^J
"1   Everything is better with bluetooth^Jbluetooth^J
"2   ^JThis is another line^JThis is a test^JThis is another line^J^J^J^J^JThis is a test^JThis is another line^J
"3   ^J
"4   ^J
"5   ^J
"6   ^J
"7   ^J
"8   ^J
"9   biscuit^J
"b   cookie
"f   bluetooth
"g   I'm blind^JS
"r   bluetooth
"-   test
".
"/   throw

Obviously, when you use the same register to cut or copy new text, the previous content is replaced with the new one. But what happens when you use the same register name but using the uppercase letter? Vim appends the new text to the content of the register. As in the example below:

This line is interesting.
This is not.
This is another interesting line.
This is completely useless.

If we want to copy only the interesting lines, we can do the following:V “fy 2j V “Fy j o ESC p.
Let us analyze that sequence: First we go into visual line mode and copy the text into the f register. Then we move to the next interesting line and do the same, but this time we use the F register character, so that we append the second line to the f buffer preserving the previous content. Then, we open a new line below the last one and paste on it the content of the f register.

I know the sequence can seem overwhelming, but you rest assured that it will become second-nature to your fingers once you have used those commands for few days. As an exercise it could be interesting to inspect the content of the registers before and after appending some text (using the :registers command).

One very special register is *. It is used to copy from/to the system’s clipboard. It can be used to paste in Vim some text copied from gEdit. It is used as the other registers.

As always, use these features as much as possible to get used to them.

Enjoy!

Vim Sheet (III)

• y: copy text. (yw copies a word, for example)
• yy: copy this line
• d: cuts the content and puts it into the clipboard
• p: paste the content of the clipboard
• ” register y: yanks the selected text into register. Example: “ty
• ” register p : pastes the content of the register.
• ” REGISTER y: adds the selection to the contents of the register (it does not delete the previous content)

In Vim, you move around the text using different commands, that is, keystrokes while you are in command mode. At the beginning this may result confusing or even seem a waste of time. However, once you get used to it, you will never leave it and you find it to be faster than any other method.

Basic movements

• h (left)
• j (down)
• k (up)
• l (right)

In most modern implementations of Vim, you can use the arrow keys to move as you normally do with other applications. However this option is not always available, mostly when you are using Vim remotely and the communication program gets confused or something. The standard keys will always work so you had better get used to them. My advice is that from now on, you use these keys exclusively.

Most of the commands can be repeated automatically just specifying how many times you want to repeat it:

ESC6j moves the cursor six lines downwards.

Moving one character at a time is not really efficient. A better approach is to move word by word. Here are some of the commands to do this:

• w (word) move at the beginning of the next word
• W (Word) the same but it “understands” special characters
• e (end) put the cursor at the end of the next word
• b (back) put the cursor at the beginning of the previous word

Let us see an example. Bold letters indicate the cursor position.

This is a text sample
w
This is a text sample
W
This is a text sample
e
This is  a text sample
b
This is a text sample
b
This is a text sample

Let us see what happens with words including special characters:

This word has different/special characters.
w
This word has different/special characters.
w
This word has different/special characters.
b
This word has different/special characters.
W
This word has different/special characters.
B
This word has different/special characters.
E
This word has different/special characters.

As you can see, the capital version of the normal commands do the right thing with these special words.

Vim knows about more text objects (e.g. lines) and because of this, you can tell him to go to the beginning or the end of the line:

• 0 move to the beginning of the line
• ^ move to the first non-blank character of the line
• $ move to the end of the line

Four other useful commands are the following, intended for placing the cursor at the first occurrence of a certain character in a line:

• f places the cursor at the first occurrence of the character
• F the same, backwards
• t places the cursor before the first occurrence of the character
• T the same, backwards

Some examples for these commands:

This is another test
fo
This is another test
Fi
This is another test
to
This is another test
Th
This is another test

The “g” family of commands are used to “goto” a specific place in the file.

• gg goes to the beginning of the file
• G goes to the end.
• numberG goes to the specific line (e.g. 5G goes to line 5)

Another equivalent method for the last one is: ESC:numberENTER

In addition, if you want to move forward and backwards one page at a time, you can use Ctrl-f and Ctrl-b respectively; or if you just want to move half-page at a time: Ctrl-d Ctrl-u. Of course the Page Up and Page Down keys of most of the keyboards work fine too, but it is preferable to use the proper commands.

These commands are sufficient to make a good use of Vim’s movement facilities. Use them as much as you can.

Vim Sheet (II)

• h, j, k, l: move the cursor
• w, W, e, b: move at the begin/end of the next/previous word
• 0, ^, $: move to the beginning/end of line.
• f, F, t, T: find a character forward/backwards
• g, G: go to a line number
• Ctrl-f/b/d/u: move page forward/backwards.

Enjoy!

OpenSSL is usually the tool used for creating an RSA key pair (the public and private ones).

$ openssl genrsa -out key.pem 1024
Generating RSA private key, 1024 bit long modulus
............................................++++++
.....++++++
e is 65537 (0x10001)

This command creates a 1024-bit key pair and stores it in a file called keys.pem. Let us see the content:

$ cat key.pem
-----BEGIN RSA PRIVATE KEY-----
MIICXgIBAAKBgQDGtQRh3WBg1ENpD8QEOGKzUHOv7Fu9bbDct8dWdCYg5mthFX35
XX/gnFrAEmrHpY1/HfZFDkowGUAatxq943o6wBZYVT8T5whkToH6ragOyM7xr7oD
gwnYRDdLMDfXuKC4x04wD1QKO/JGH94dGZB39bNHG+i4SG60lJNCZdiVtQIDAQAB
AoGAYbDFAsgvhetVaOWTXO/LtpSrC6aMQ8kV1q2TlvFrfWlLCWPjlyFcqTS1eRCU
5qqBsiks1i58UsFXPssenpSjljjKXN09Pa9s4k3osmIm0FWh77Fn6ddiddvv3n0A
QVcAf4PeGwE8RyoBxkXmaK0G3JJEN2D6Ue9vJm7ODZ3d0NECQQDphmExZdmiF5GV
2cvou6gjAngVteFgDCvhK3xCqdmIaz3he2TWRlMsJicOZmrXCZR/IRLJuSsKUBTm
XXdY05C/AkEA2dTKfXzIpSeZx0jN2ETUQi1uCdOb5a6XVBhXvYr0gDhaKO7dqU/A
/bztdbuXylU7rf3mGOboaOux6FWqqoiCiwJBAKdEJ43YZCBkPVVWYWXcNDyPYjA6
zKmdTjjEiwa83iGGnxZI6htI1/5Bfawk09Ye+IxuxiRTS27hmXa/7+Jh98UCQQDW
2YrfOrSsMOL8LFLbfQfePfDKwGyDnjCkQV5JFUUTMoG63d7DoGY53p5YAS814dt7
QXIyHY4d7lsLTXOHwB0BAkEA6MseICM41X0NaAsB4xFtMt4vBtv4OfIVUiPdeI8p
bmhKkzUdphWPWsVUTEim42zDHLLPwhEItPxVgk58/Bv3YA==
-----END RSA PRIVATE KEY-----

If you add the -des|-des3|-idea option, the private key will be encrypted with the chosen cypher. If this option is used a passphrase will be asked for.

$ openssl genrsa -des3 -out keydes3.pem 1024
Generating RSA private key, 1024 bit long modulus
..++++++
....................................++++++
e is 65537 (0x10001)
Enter pass phrase for keydes3.pem:
Verifying - Enter pass phrase for keydes3.pem:

Now, you have a private key encrypted with the DES3 cypher in a file called keydes3.pem:

$ cat keydes3.pem
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,90A0901B038FDB04

Y2Vuba/ALHPffCMFU2uEk/mF43DEuKBuFek/wSPxaacm1r2tjSmwgyCNluxYqLhD
huZX986L4MjEKNFkrKWvuTaw9xZbObUNz7KhUC1KrMjhOXzr/zA9NKDs/DvfJaGw
DQLJYx6acqlWToxJoi2on3oBZj7SdOAkqrnT2RaLWCRyMPgsXrJFc+pYIgSeIQ48
OT0lZpZYgw0uTuEaPvSF1QxkJ6rewseSuXz4OPipSYYVcSM7n3DpXiTeci2Dq8q8
Bl1HP/VcQG5wzB+VACJa3KZqqrEiVZU8DaFlFN2Ir4AEiqNomNzij+XgYOdZzVrA
FYmjGbtNC3vGS1x0YFqsRjGmkuKjI+EioCj5fN7S2TkfSFK+tRjEFtHhHihaGOz+
m6mHbu8tErue1wqNqprJ9KdjTSrP4yR0hAfQF4bjqrpe4ExqvBLODw2TUz03ld6y
mBr7J16MEfg+wb22lt5wyX59uUxNdsu4j6H/Vgg/TmACuADNzWx9Hst6cmVQbuN3
VXfDCP5G79UiihLIug/C+uswiAUA6jluh787NjowA8QXuMYRmTECeKHWezZuf+sQ
x9n0gMWMS9HQdg7gFRNc+Hg0JeW8YBGcYzDdQVXvPrgI30apKDidFf9jjLXaQQoq
OZVq0QC60XHF6UG9/nSoGj7VPAkj9b0+4lzBLCRikebrRQhLhBGsCy30J3WrGzei
UGGjeR4mPiZ6gG41MEQFZhr1Wy6I44f3Eln4qdaUDPhnusp0lv1QM5U41IgrVS6+
fnY2DivXaHil2Rl/GLz1GT7N60fqtK5g+wUeZGAmuodjGR3GGuGHog==
-----END RSA PRIVATE KEY-----

As a matter of curiosity the symbols shown during the creation indicate its progress. RSA private key generation essentially involves the generation of two prime numbers. A . (dot) represents each number which has passed an initial sieve test, + means a number has passed a single round of the Miller-Rabin primality test. A newline means that the number has passed all the prime tests (the actual number depends on the key size).

I have used the .pem extension because PEM is the default format in which the keys are stored. It consists of an ASN1 DER encoded form (compatible with the PKCS#1 RSAPrivateKey or SubjectPublicKeyInfo format) base64 encoded with additional header and footer lines. There are two other common formats: DER and NET.

To output the public part of a private key:

$ openssl rsa -in key.pem -pubout -out pubkey.pem
writing RSA key

This way you get the public key in a file called pubkey.pem:

$ cat pubkey.pem
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDGtQRh3WBg1ENpD8QEOGKzUHOv
7Fu9bbDct8dWdCYg5mthFX35XX/gnFrAEmrHpY1/HfZFDkowGUAatxq943o6wBZY
VT8T5whkToH6ragOyM7xr7oDgwnYRDdLMDfXuKC4x04wD1QKO/JGH94dGZB39bNH
G+i4SG60lJNCZdiVtQIDAQAB
-----END PUBLIC KEY-----

If you want to delve into RSA, you might want to view the modulus, exponent and prime key values:

$ openssl rsa -in keydes3.pem -noout -text
Enter pass phrase for keydes3.pem:
Private-Key: (1024 bit)
modulus:
    00:b0:ec:02:82:c2:c7:db:45:fd:34:df:bc:6a:bf:
    c1:cf:71:c9:07:87:64:b2:cb:ee:76:82:de:1a:a9:
    67:a3:7d:e0:31:d1:5b:ec:7e:34:3a:6e:a8:9b:74:
    c7:1d:70:52:bf:6a:a2:f1:d3:03:01:98:86:bc:83:
    dd:7f:2b:a6:18:ef:8e:f8:2b:6a:44:7d:33:6e:c5:
    e1:ba:85:b0:9c:e1:ae:52:ff:14:0b:ed:30:98:52:
    c5:e9:fd:82:00:40:dd:85:80:ca:f6:7d:48:74:56:
    5b:7e:5e:a4:4f:62:d3:60:f6:a1:7d:2d:66:2c:06:
    31:93:1d:69:bb:68:84:87:61
publicExponent: 65537 (0x10001)
privateExponent:
    00:99:88:66:71:65:69:1c:bf:b3:09:b4:73:85:4b:
    dd:7c:11:69:7c:50:21:b2:0b:c9:68:2d:0f:63:a1:
    c9:5f:96:f7:fd:23:8b:1b:43:36:3d:d3:14:1c:bc:
    0d:a3:5d:7b:61:c3:bf:9e:0e:19:58:c4:2d:80:e1:
    0a:51:b6:e6:4e:e1:84:03:bb:ae:91:58:c3:fc:e1:
    a7:7d:69:4a:34:3c:e1:c8:ff:95:2e:69:bc:0e:4e:
    0f:b7:8b:a3:e7:c7:9c:43:01:0c:84:db:16:d9:58:
    91:02:12:75:38:83:0e:b9:ed:13:0b:00:80:07:a4:
    09:14:25:91:63:72:4d:a0:b1
prime1:
    00:e0:9c:c6:5a:de:23:b9:4a:7c:9b:43:46:93:d1:
    91:e2:40:db:64:70:9d:3a:64:b5:56:16:0c:55:8e:
    89:92:5c:cd:bb:77:e5:08:f7:3b:9c:41:76:6b:f0:
    67:ae:48:38:9f:2a:6e:b9:ce:e3:14:08:ad:fe:c1:
    b0:57:a5:6e:bd
prime2:
    00:c9:a5:2a:ff:21:28:f4:c0:67:9c:42:b1:c9:df:
    f4:4f:a0:5b:e4:85:6f:a1:6c:89:4e:d8:04:d1:e4:
    47:6a:87:75:3d:a6:55:36:ab:5c:9f:63:be:c9:7a:
    9a:ae:d8:0b:2b:7f:36:5e:e8:54:56:9c:6e:b4:ee:
    d7:eb:64:c7:75
exponent1:
    00:80:21:af:1d:e3:1f:29:f2:8e:06:dc:68:04:a7:
    46:bb:75:18:32:c1:f3:4f:7e:67:db:c6:14:1f:32:
    82:d4:55:d0:9f:23:14:2a:fb:2e:ac:42:c3:d5:6b:
    7d:19:f4:e5:28:17:42:b7:08:88:8d:c3:2d:ce:e8:
    9b:3a:44:8b:59
exponent2:
    0f:db:9f:70:05:09:95:85:f4:20:03:d6:bb:8b:93:
    49:17:d1:62:3d:64:34:0b:b7:18:ae:40:62:c9:53:
    1c:7b:9e:aa:c4:83:fb:12:aa:ec:16:0a:11:0a:45:
    53:ee:c5:a2:1c:15:08:8d:b8:e4:3e:d5:2e:01:82:
    95:8e:8d:69
coefficient:
    00:bb:60:d9:2e:14:9c:18:76:e7:ed:c8:0f:de:b6:
    ff:a3:ae:c2:6f:da:7b:b3:5c:61:22:5d:45:50:2a:
    38:75:28:d4:75:5b:12:ba:04:48:73:b7:a3:8d:44:
    74:24:2d:71:0e:fa:c3:e2:cc:9a:3f:e4:22:ed:ab:
    13:e8:0d:79:98

As you can see, when you proccess encrypted RSA keys (as we did with keydes3.pem), you will have to enter the passphrase.

For more info, man openssl, man genrsa and man rsa.

Runs all init scripts (located in /etc/init.d), in alphabetical order, with the status option.
Note: Only in Red Hat and redhat-like distros (Fedora, Mandriva,…).

The above installs finch. It is an ncurses based instant messaging client, part of the pidgin suite. Though it can be a little tough at the beginning, it is a good alternative if you do not have a graphical interface. Below I show two screenshots. Use Alt-w to move between windows.

Enjoy!

Verifying MD5 or SHA-1 digest is highly recommended when you download new software for your system.

In most of Linux distros the md5sum and sha1sum commands are available:

$ md5sum ubuntu-9.04-desktop-i386.iso
66fa77789c7b8ff63130e5d5a272d67b  ubuntu-9.04-desktop-i386.iso
$ sha1sum ubuntu-9.04-desktop-i386.iso
19aabf327fdbde9e66db54dc04e3a83b92f70280  ubuntu-9.04-desktop-i386.iso

Solaris (even version 10) doesn’t ship either with md5sum or sha1sum installed. However you can use digest:

% /usr/bin/digest -a md5 GNUgcc.3.4.4.SPARC.64bit.Solaris.10.pkg.tgz
498c344fe2839631bb7cf4b869b7b830
% /usr/bin/digest -a sha1 GNUgcc.3.4.4.SPARC.64bit.Solaris.10.pkg.tgz
a8da8247900dd06a7000fd0e6d41f834d6ab3e40

And in Mac OS X, openssl is the appropriate tool:

$ openssl md5 svnX_0.9.13.dmg
MD5(svnX_0.9.13.dmg)= 90c95c92fb466b2252f1694bf544a05d
$ openssl sha1 svnX_0.9.13.dmg
SHA1(svnX_0.9.13.dmg)= a6909991e4cf7422e52bae050f7c69975baf595e

$ source ~/.bashrc

or the even simpler

$ . ~/.bashrc

$ yes
y
y
y
y
y
^C
$

It is useful when you are sure what you are doing. For instance, if you want to delete a set of write protected files:

$ yes | rm file_proctected*.txt

Enjoy!