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”.

Most people prefer webmail, especially Gmail. Webmail is very easy to use and does not require much configuration. Gmail is the most wonderful webmail. It groups messages by threads and it has a powerful searching tool. You can easily find out what you want from the mass.

However, one drawback of webmail is that you cannot access your mail off-line. Although Gmail started to support off-line email recently, I still think that keeping the emails in my local storage is safe and reliable. Moreover, an email client is generally much more customizable than webmail. So, I am using Evolution, which is the most powerful and standard email client in Linux, to receive and send email everyday.

As said in the beginning, I want to figure out what email clients my contacts are using. This work is not hard. There might be some fields in the header of email indicating which client this email is generated. The field could be named “X-Mailer”, “X-mailer”, or “User-Agent”. In Evolution, you can open the menu “Edit>Preferences>Mail Preferences>Headers”, and check the “Mailer”. Then you could see the Mailer information in your mails. Some mails are composed without the Mailer information. I don’t know why. We just ignore the mails without Mailer information.

Evolution stores mails in the folder “~/.evolution/mail/local/Inbox.sbd”. Under this folder, the files without extension are the mail files, which included all the contents of your mail. So, we can grab Mailer informations from these files.

First, we can use “grep” to filter the lines containing “X-Mailer”, “X-mailer”, and “User-Agent”. We can store them into a file.

cat mail-box-name | grep X-Mailer > outfile

cat mail-box-name | grep X-mailer >> outfile

cat mail-box-name | grep User-Agent >> outfile

“mail-box-name” is the name of the mail files. Carefully name the outfile. Don’t let it overwrite the existing file. My suggestion is that you can copy all the mail files to another place and do these operations there. It’s safe.

Now we get the outfile containing Mailer information. The next step is removing useless information from this file, such as the header “X-Mailer” or the version information. This is the most boring part. Maybe there are some sophisticated methods which could do this work automatically, but I am lazy to think them up. For me, I use Vim and block-edit the text (ctrl+v, then move cursor), and this work is done without much effort. Now we get the file like this:

…
Moto-EZX
Moto-EZX
Moto-EZX
Mozilla
Mozilla
Mozilla
Mutt
Mutt
…

Then we should count them. Use this command:

uniq -c inputfile > outputfile

Finally we get the file like this:

…
84 Evolution
182 Foxmail
1956 G2/1.0
…

Maybe we need some refinement for these data. For example, remove the very rare entries (e.g < 10), and remove the entries that are obviously web server, such as “ASPMail”, “PHPMail”, etc.

After refinement, there we come to the OpenOffice Spreadsheet for analyzing these data. Again, we use Vim and block-editing to separate the count and client name, and paste them into Spreadsheet individually. Then open “Insert>Chart” and generate your favourite chart.

Following is my data, in which the size of sample is 3003 (after refinement):

From the chart we can see the most popular email client of my contacts is Gmail (G2/1.0). Following are Thunderbird and Foxmail. Then it comes Evolution, Apple Mail, SquirrelMail, Outlook and SFUwebmail.

Which client are you using?

For me, the must-have feathers of a source browsing tool should be:

1. Syntax highlighting
2. Friendly user interface
3. Identifier and function search

If you are a Windows user, you might have heard about Source Insight, which is a non-free software. I haven’t used it, so I am not going to comment it.

For Linux user, the first tool I want to mention is Source Navigator. It is developed and supported by Red hat. It supports C, C++, Java, Tcl, FORTRAN and COBOL. It’s very powerful. But if you just want to browse sources, I don’t recommend you to use it. Since it GUI is developed in Tcl, an ancient programming language, the user interface is not very friendly. I bet you don’t like it.

Another wonderful software is Doxygen. Although it aims to generate documents various programming languages, including C++, C, Java, Objective-C, Python, IDL (Corba and Microsoft flavors), Fortran, VHDL, PHP, C#, and to some extent D, you can treat it as a source browsing tool. It can generate documents in HTML format. So you can read them via Firefox. If the source code is well commented following JavaDoc’s style, a beautiful documents describing classes, variables, functions could be generated. If the source code is not commented in JavaDoc’s style, the documents could also be generated, but it just have source codes, without these detailed description about classes, variables, and functions. Doxygen can also generate class-graphs, call-graphs and other similar graphs in UML style, which will help you understand the source.

The disadvantage of Doxygen is that its search result is somehow coarse-grained. It cannot distinguish variables from functions in search result. And it cannot differentiate definition, declaration and reference. So, if you are dealing with a huge project, you may find it uncomfortable to read source generated by Doxygen.

The ultimate tool, in my view, is LXR, which stand for Linux Corss Referencer. Specially, it may be the best choice for you to read Linux source code. Although, namely, LXR aim for Linux source code, it suitable for other projects written in C/C++, COBOL, Java, Perl. It is a web based tool and you can read the source code via Firefox. It uses a database to management cross references. So the search result is very accurate. And it can differentiate definition, declaration and reference.

LXR is famous for its difficulty on setup and configuration. And its user interface cannot be called “beautiful”. Luckily, the next generation, LXRng (demo) is available now. LXRng has a very beautiful and friendly user interface.  Moreover, setup and configuration for LXRng is much simpler than LXR. However, it seems that LXRng currently only support C language. If you need it for C++, you need a slight hack:

Locate to your LXRng’s installation directory, then open this file:

lib/LXRng/Lang/C.pm

Find the following code from this file:

sub pathexp {
    return qr/.[ch]$/;
}

And change it into:

sub pathexp {
    return qr/.[ch]$|.cpp$/;
}

Then LXRng should support the C++ files.

Doxygen and LXRng could satisfy most of your requirement. Maybe reading source from Firefox is strange and unfamiliar to you, but I think you will going to like it if you just have a try. If you have no idea about how to use them, just go to their websites, where you can find plenty of documents and toturials.

I just created my first video DVD. My experience may help you get less trouble on burning your video DVD on Ubuntu/Linux.

Most DVD videos are encoded in MPEG-2 format. So, if your original video is not encoded into MPEG-2, the first thing you need to do is to transcode it into MPEG-2. There are lots of powerful tools to handle it, such as ffmpeg and mencoder. They are command-line tools. If you are a crazy fan of command line, you definitely should try them. However, the command line arguments will generally be 10 lines! If you cannot handle them(like me), just try some GUI tools.

The first option is Avidemux. It’s powerful and easy to use. However, its H264 support is poor. When I tried to transcode a H264 video into MPEG-2, it crashed every time. Maybe it works fine with other format, but I have no chances to take a try.

Another great transcoding tool is Hyper Video Converter. It’s a front-end of ffmpeg and mencoder. Although it looks a bit “Shanzhai”, it’s more powerful than its appearance, since it’s the frontend of powerful ffmpeg and mencoder. It’s quite reliable. I used it to transcode my H264 “mkv” file into MPEG-2 “mpg” file. I recommend you to use it, if you have no requirement on gaudy appearance. The KDE version is here.

Then it goes to create DVD file structure. Generally, we need a folder contains VEDIO_TS and AUDIO_TS folders and put some necessary information files in them. This work can be done by dvdAuthor. It’s also command line based tool. As introduced in its website, there are several frontend for it. The most famous one is QDvdauthor. The newest version for Hardy in Getdeb is 1.5.0, which is even lower in repository. 1.5.0 has much bugs in creating subtitles, You should use the newest version, 1.7.0, which is available in Getdeb for Intrepid. I am using Hardy, so I compiled 1.7.0 and created a deb package by myself. Grab it if you need.

Now, we are using QDvdauthor 1.7.0. Just create you your DVD file structure using the MPEG-2 video encoded by Hyper Video Converter. There are some tutorials for QDvdauther. Just take a tour if have problems on how to start.

Once you get the DVD file structure including VIDEO_TS and AUDIO_TS, you can test them via VLC or SMPlayer. Take SMPlayer for example, select “Open”->”DVD from folder” to test the video.

If everything works, you can create an ISO image. I recommend you to create ISO image and burn image by your self, using genisoimage and K3B. Because there are much things that you can control. The most important thing is that current version of genisoimage has a huge bug. The image created by it is not readable by Windows and standalone DVD machine. This bug is not solved in even the latest version 1.9.0. You have to downgrade you genisoimage into 1.2.0 from debian repository.

One thing that QDvdauther cannot control is the volume name of the image. This is why I recommend you to create ISO image by yourself. You can use this command:

genisoimage -dvd-video -udf -V “Volume-Name” -o “dvd.iso” “DVD-folder”

“dvd.iso” is the ISO image you are going to create. And “DVD-folder” is the folder contains VEDIO_TS and AUDIO_TS folders.

Then, add the Error Correction Codes(ECC) to the image

dvdisaster -i “/tmp/Unnamed/dvd.iso” -mRS02 -n 350000 -c

If this command issues error message, maybe you should remove the option “-n 350000″ or adjust it.

At the last step, burn this ISO image by whatever software you like.

Enjoy your video DVD created on Ubuntu/Linux!

Following is the deb package of QDvdauthor 1.7.0. It could be installed on Ubuntu 8.04.

qdvdauthor-170_deb

The wiki I used in my homepage is Dokuwiki. The most great feature is that it does not require database connection. It’s very convenience for personal usage.

I have two Dokuwiki maintained. One is located in localhost, another in the webserver. I always edit the pages on localhost, and synchronize them to the webserver at times. Since Dokuwiki is totally PHP based, without database such as MySQL, I only need to synchronize some files.

All the changes on wiki are reflected on the folder “data” in your Dokuwiki path. So every time, I only need to synchronize this folder.

The best way to communicate with webserver is SSH. Fortunately, my webserver Godaddy support SSH access. Another thing need to concern is synchronizer. Here I use Unison. The best description of Unison comes from it’s the author of this software:

A file-synchronization tool for Unix and Windows
Unison is a file-synchronization tool for Unix and Windows, written
in OCaml. It allows two replicas of a collection of files and
directories to be stored on different hosts (or different disks
on the same host), modified separately, and then brought up to
date by propagating the changes in each replica to the other.

Unison offers several advantages over various synchronization methods
such as CVS, Coda, rsync, Intellisync, etc. Unison can run on and
synchronize between Windows and many UNIX platforms. Unison requires
no root privileges, system access or kernel changes to function. Unison
can synchronize changes to files and directories in both directions,
on the same machine, or across a network using ssh or a direct
socket connection.

Transfers are optimised using a version of the rsync protocol,
making it ideal for slower links. Unison has a clear and precise
specification, and is resilient to failure due to its careful
handling of the replicas and its private structures.

If you are using Ubuntu machine, you can install it from the repository just by one command:

sudo apt-get install unison

There is also a gtk front-end for this software: unison-gtk, but I think it’s useless at most time.

Now, another problem comes to front–in order to synchronize files with SSH, both installations of Unison on client and server are required. However, at most time, you don’t have the permission to install software such as unison on SSH server. Here, we attack this issue by SSHFS. It allows you to mount a remote folder on your machine via SSH.

Everything is OK. I wrote a small script to handle the synchronization:

#!/bin/sh
sshfs -o workaround=rename username@sshserver:/path/html/wiki wiki-remote/
echo "Synchronising with sshserver"
unison /var/www/dokuwiki/data ./wiki-remote/data 
  -fastcheck yes 
  -ignore 'Path cache' 
  -ignore 'Path locks'

Modify it to fit your actual environment. Note that the argument of sshfs command “-o workaround=rename”, this prevents the “renaming problem“.

All things done. Excute this script. Or, you could add an cron job to run this script automatically once per day. Have fun in synchronizing files with SSH!

Although sometimes software need upgrading, in order to fix bugs, or add new supporting, when you find bugs, there are only two things you can do for it. The first is fixing it yourself, while the second is waiting for upgrade. On the other hand, you might find some bugs appears after you upgrading a software, which worked well before. It’s hard to tell why we are willing to upgrade it. Just for upgrading?

Almost 5 months have passed since Ubuntu 8.04 “Hardy Heron” had released. And even “Intrepid Ibex” is coming within one month. I, should like changing, still used “Gutsy” in my laptop. There are several reasons why I keep using it. It’s hard to make all parts of my laptop Dell 1420 work well under Ubuntu 7.10, including the sound card, wireless, and microphone. Thank Dell Ubuntu Wiki a lot to provide patches to fix these issues. About 5 months ago, when “Hardy” was just released, the entry “Known Issues” in Dell Ubuntu Wiki is empty. I cannot put myself in hell to try the new release. Fortunately, issues have be found and fixed now for “Hardy”. I can upgrade my system safely–at least in image.

Another thing is that I have patched something on the kernel, such as VBox. I don’t want to repatch them after upgrading. And I was afraid that some software may don’t work after upgrading to “Hardy”. I have no time and don’t want to reinstall and reconfig them. Maybe a small issue can cause the damage of entire system. Then, I have to reinstall everything, and encounter all kinds of problems. A good thing is that I have my /home located in a separate partition. If my system is down, at least I can retain the things under my home folder, which are very very important.

I have one thousand reasons for not upgrading. However, how could you image that the software you are about to install depend on a newer version of “libglib” or “libc6″? Pidgin 2.5 support off-line messages for MSN, which I desired for a long time. When I tried to install it, it told me that it need a newer version of “libglib”. That meant I have to upgrade almost everything. Sounds like hell. Finally, I decided to do upgrade for Ubuntu.

The whole process took me an afternoon. I followed the official guide. It was not very hard. After downloading everything, dialogues popped up one after another. After I handled all of them, upgrading is over. The following thing is following the Dell Ubuntu Wiki to fix issues. At last, everything seems work fine, including microphone.

The last thing is installing Pidgin 2.5, for which, seems, the whole upgrading is processing.

After considering several distro, I chose slax linux. I think I’ve been influenced a lot by my friend Jiawei who had used slax linux when his hard drive was down.

After installing slax linux on my USB drive correctly following the official manual, I found it didn’t support Chinese at all. When I googled that, I found fanx, a localized slax. Since I am the people who like solving problems in a more challenge way, I didn’t choose that.

For the first thing, I downloaded the modules for i18n of Chinese packages from here. The only packages I needed are the files start with 001, 002, 003, 004, 010 and 011. Put them on /slax/modules on my USB drive.

After started it(don’t choose the “fresh mode” or “copy to ram” mode), modify /etc/profile.d/lang.sh. Added the following lines:

export LC_ALL=zh_CN.UTF-8

export LANG=zh_CN.UTF-8

And commented all other lines by add ‘#’ at the first of the line. So simple!

You may also want to use your favourite fonts. Then, copy the ‘.ttf’ fonts to the folder /usr/share/fonts/TTF

Every thing is OK now. After short configurations, it can display Chinese characters as well as with Chinese input method available. Let’s enjoying the beautiful, lightweight and portable linux.

Before writing 70-647 and 640-816, make sure that basics like 70-271 and 70-293 are cleared well in advance for PMI-001 and eventually 350-018.

If “UNIX time” is selected, what will happen?

Cool! This is the time here. Isn’t it interesting? Well, it may be confusing as hell, and you may ask what’s the time it is. Let’s investigate what’s Unix Time.

Unix time is displayed in seconds elapsed since January 1, 1970. It is stored in a 32-bits integer, time_t. So, it looks like this.

But there is a small issue there, say, as long as the largest integer a 31-bits(1 bit for sign bit) number can represent is 2^31 that is 2147483648. So large? What time it is? It is exactly 03:14:07am(GMT), January, 19th, 2038. This is the famous 2038 problem. After this time, the variable will turn into 10000000000000000000000000000000, which is -2147483648 in decimal. Is that tricky? What’s the time then? May be 8:45:52pm, December, 13rd, 1901. Wow, it’s really a big problem, almost all the computer will be crashed at that time. Is that true? Of course, but I don’t think that will be a critical problem, because after 30 years, almost all the computer will be upgraded in to 64-bits or even 128-bits(256-bits?). The problem will be easily fixed then. So, just think it as a tricky, rather a problem.

At last, I want to say, enjoy your Unix time! You know, developers are the primary users of it.

Not all 650-393 students are qualified for 642-446 or 642-503. They need to write 156-215 as well as 642-436 in order to prepare for 70-284.

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