Let me give you an example to show Python’s awesomeness and attractiveness.

Refer to this page for the problem. We are asked to compute the first ten digits of the sum of one-hundred 50-digit numbers:

37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
…

Suppose you are using C/C++, you probably need to use array to handle each digit of these long numbers, since these languages don’t support such long integers. If you are using Python, things will be very easy.

Just copy/paste these numbers into a file. Edit it with Vim. Use Vim command:

:%s/$/,/g

to add a comma to the end of each line. Remove the last comma. Then insert “array = [” to the beginning of the first line and add a “]” to the end of the last line.

Add the following to another line:

print sum(array)

Save this file and run it with Python and here we are done.

Here you can see that Python can handle arbitrary large number, as long as you memory can hold it. This is just a tip of the iceberg of Python’s advantage. Use it and you will get more and more.

Which editor are you using, Vim or Emacs? And why?

Next time, when you are arguing with other people about which editor is better and trying to persuade others to use your favorite editor, just forget it. If you believe everything is in destiny, it is not an exception for the editor you choose. The choice is written on your fingers.

Several days ago, I learnt from Mike that the choice between using Vim or Emacs depends on your fingers. As he figured out, people have longer fingers prefer to use Vim, while people have shorter fingers prefer to use Emacs. It is amazing, but reasonable.

Using Vim, the most frequent key you hits might be the “Esc”. Vim has three modes: insert mode, command mode and visual mode. Command mode is the bridge of other two modes, and most of navigating and searching is done in command mode. So, when you are using Vim, you must: press “a” or “i” to start insert mode and input something, then press the “Esc” to enter the command mode and do navigation, then enter the insert mode again and then press the “Esc” to the command mode. Maybe some times you want to hit “v” to enter the visual mode to select something, and after that you must hit the “Esc” again back to the command mode. At most time, you are hitting the “Esc”. That’s why they call Vim “hit Esc to death”. Of course, you also need Ctrl and Shift in vim, but not so often. For example, when you select contents by line or by block, you will press “Shift+v” or “Ctrl+v”. When you want to jump to the end of a line, you will press “$”(Shift+4). But these cases are much rearer than hitting the “Esc”. So, when your fingers are long enough, you will find it very comfortable and easy to hit the “Esc”. Maybe that’s why you like to use Vim.

I have touched Emacs for little times. In Emacs, almost everything except for inputing text are done by “Ctrl+something”, “Shift+something”, “Alt+something”, or even “Ctrl+Alt/Shift+something”. That means at most time, one of your finger must hit “Ctrl”, “Shift” or “Alt”. That’s why they call Emacs “hit Ctrl to death”. Some Emacs fans even want to use pedals to help them hit hot keys. I have to twist my fingers to hit those keys. For some complicated combination of keys, I even don’t know how to hit them comfortably and elegantly. So I gave up Emacs soon to save my hands and fingers. Maybe people who have shorter fingers would fall in love with Emacs because they could hit these hot keys easily without twisting their fingers very much.

Although I prefer Vim, I don’t mean to comment Emacs and Emacs users. Emacs is also powerful, and even more powerful than Vim (at least in my mind). I admire Emacs users very much because they can learn so many hot keys by heart and use them gently and easily.

If you are still confusing about choosing Vim or Emacs, just check your finger. If your fingers are longer than most of your friends, then just choose Vim without hesitate and you will like the life of hitting the “Esc”. If your fingers are shorter than average and you find it’s uncomfortable to hit the “Esc” frequently, then you should definitely choose Emacs.

If you are still arguing with other people about Vim and Emacs, forget it, unless you want to cut some one’s finger to force them to use Emacs or lengthen some one’s finger to force them to use Vim.

If you are jeered by Emacs users for you are using such a disharmonious editor that has multiple confusing modes, you could respond them, “at least I have beautiful long fingers”. If you are sneered by Vim users for you are using such a complicated editor that requires a pedal to handle the hot keys, you could respond them, “at least my memory is better than you, since I could remember thousands of hot keys”.

First, I will show you the screen shot The screen of vim is divide into two sub windows, the top one can display the code and the bottom one shows the variable you want to watch. Well, this can be changed by you, you can split the window any way you like. You can use C-B to make a break, and press R to run your program, and press S to step, and C-J to add the variable you want to watch. You can download clewn here:

http://clewn.sourceforge.net/

How to install: first of all, you should have your gvim installed,

sudo apt-get install vim-gnome

as well as gdb And then download the source file of clewn; note here, not vimgdb. And extract the file, then use your terminal to enter the clewn folder

./configure make sudo make install

Note here, may be some one will be suffered from the dependency problem during their installing. If your machine tell you that you need readline, then install libreadline5-dev

sudo apt-get install libreadline5-dev

And then, copy some files to ~/.vim you can refer my folder:

cp /usr/local/share/vim/vimfiles/clewn.vim ~/.vim/plugin/

cp /usr/local/share/vim/vimfiles/doc/clewn.txt ~/.vim/doc/

cp /usr/local/share/vim/vimfiles/macros/clewn_mappings.vim ~/.vim/macros/

cp /usr/local/share/vim/vimfiles/syntax/gdbvar.vim ~/.vim/syntax/

Then, every thing is done. You can write a small program to test.

#include 

int main(int argc, char *argv[]) {
  int i;
  int s;
  s = 0;
  for (i = 0; i < 10; ++i) {
    s = s + 1;
  }
}

Save it as test.c , for example. And then,

gcc -g -o test test.c

If everything is right during compiling, then

clewn -va test.c

Then, gdb is opened on your terminal, and your gvim is opened at the same time Cool down now; input the following on your terminal(gdb):

file test

Now, you can debug your program on gvim. For example, you can click the line you want to set break point. And then press CTRL+B, then, break point is set. SHIFT+r（that is capital R）It will run and stop at your break point SHIFT+s（that is capital S）It will step And watch your variable, input following on gvim

:split

Then the window will be split, and then click the variable you want to watch, and press C+J, then you can see the variable appears in another window. To do this, you also can input the following on your terminal(gdb)

createvar yourvar

“youvar” represents the variable you want to watch. Following is the default shortcuts

List of default key mappings:

        CTRL-Z  send an interrupt to GDB and the program it is running
        B       info breakpoints
        L       info locals
        A       info args
        S       step
        I       stepi
        CTRL-N  next: next source line, skipping all function calls
        X       nexti
        F       finish
        R       run
        Q       quit
        C       continue
        W       where
        CTRL-U  up: go up one frame
        CTRL-D  down: go down one frame

cursor position: ~
        CTRL-B  set a breakpoint on the line where the cursor is located
        CTRL-E  clear all breakpoints on the line where the cursor is located

mouse pointer position: ~
        CTRL-P  print the value of the variable defined by the mouse pointer
                position
        CTRL-X  print the value that is referenced by the address whose
                value is that of the variable defined by the mouse pointer
                position
        CTRL-K  set a breakpoint at assembly address shown by mouse position
        CTRL-H  clear a breakpoint at assembly address shown by mouse position
        CTRL-J  add the selected variable at mouse position to the watched
                variables window

This is referred the official document, which is available here

http://clewn.sourceforge.net/doc.html

Hope this will help you somewhat. If you have some new or better idea, please contact me. chunhao86@gmail.com Thanks