I Googled around and found some hints using “latex.eval(‘$x^2$’, {}, debug=True)”. This gives details on what Sage does underhood. In my case, the absence of “gs”, i.e. GhostScript, fails ImageMagick’s “convert” utility, which is invoked by Sage to convert a .ps file to a .png. So I just

sudo brew install gs

then everything is good! However, please note that beforehand I already had TeX Live, ImageMagick and libpng installed. I’m not sure but you might want to secure these boys, too.

sudo brew install imagemagick
sudo brew install libpng
sudo brew link libpng

And just Google for TeX Live!

Btw, with the command line interface, “latex.eval” would save your .png files under where you started Sage. It’s an excellent way to generate snippet images for math formulas – you don’t have to write the whole \begin{document} thing at all!

Finally I encountered nohup and disown!  If you’re interested, read this and that.

Note that wikipedia mentions start-stop-daemon.  This is what I used to overcome the problem!!!  The ‘at’ command is also good.  However on Mac ‘at’ is implemented by launchd and by default disabled.  Talk about learning new stuff everyday pal!

* APUE is the famous “Advanced Programming in the UNIX Environment”.

vim
echo $?

and

/usr/bin/vim
echo $?

you can see the difference.  A ‘which vim’ shows /usr/bin/vim so I have no clue.

I noticed this because Mutt reported “Error on running ‘vi /var/tmp/some-random-tmp-file’”.  It doesn’t really break anything but it’s annoying.  Obviously Mutt depends on Vim’s exit code to decide this.  Specifying “set editor=/usr/bin/vim” in muttrc eliminates the problem.

And … no I’m not alone.

Luckily it is not very hard to add custom language support to ctags, so not only can we jump around in source files, but we can also make use of other Vim plugins like FuzzyFinder to release the full potential of tags. Here’s how.

To add our language, LZX, the simplest way is to use ctags’ command line options. Since the options are many, we write a file containing them all:

--langdef=lzx
--langmap=lzx:.lzx
--regex-lzx=/^[ \t]*<class[ \t]*name=["']([A-Za-z0-9_]+)["']/\1/c,Class/
--regex-lzx=/^[ \t]*<method[ \t]*name=["']([A-Za-z0-9_]+)["']/\1/m,Method/
--regex-lzx=/^[ \t]*<handler[ \t]*name=["']([A-Za-z0-9_]+)["']/\1/h,Handler/
--regex-lzx=/^[ \t]*<attribute[ \t]*name=["']([A-Za-z0-9_]+)["']/\1/a,Attribute/
--exclude=*.as
--exclude=*.bat
--exclude=*.cc
--exclude=*.h
--exclude=*.htm
--exclude=*.html
--exclude=*.java
--exclude=*.js
--exclude=makefile
--exclude=*.mk
--exclude=*.php
--exclude=*.pl
--exclude=*.pm
--exclude=*.py
--exclude=*.rb
--exclude=*.sql
--exclude=*.tex
--exclude=*.vim
--links=no

–langdef indicates the name of the user-defined language, while –langmap defines the suffix of its source files. –regex-<LANG> defines the patterns ctags uses to extract tags. The use of –exclude is obvious – I don’t want to collect information (tags) from these files for a LZX project. –links just tells ctags to ignore symbolic links.

Then this is how we tell ctags to use above options and generate tags:

ctags --options=ctags-lzx -f <PATH-AND-NAME-OF-THE-TAGS-FILE> -R <BASEDIR-OF-SOURCE-CODE>

Naturally, -R means recursive, and -f specifies our tags file. Normally Vim will pick up the tags file if we follow good habit, but if it doesn’t, we can tell it by:

:set tags+=<PATH-AND-NAME-OF-THE-TAGS-FILE>,<EVEN-MORE-TAGS-FILE>

Then we are ready to jump to most definitions and back by ctrl-], g] (for multiple matches) and ctrl-T! With FuzzyFinder, try “:FufTag<CR>”. I’ve already mapped it to “<LEADER>t” since it’s so brilliant! (Try also “:FufFile<CR>” to “<LEADER>f”, “:FufBuffer<CR>” to “<LEADER>b”, etc.)

实际上我用fink装的第一个软件就失败了 － mutt（fink -b install mutt，因为没有binary包所以不能用apt-get）。错误信息是令人挠头的“Failed: Fink::SysState: Could not resolve inconsistent dependencies”。官方给的解释是他们计算dependency的引擎不够强大，当dependency很复杂的时候就会错。这在Ubuntu的aptitude上是不可想象的：不够强大还好意思出来混么？！当然fink是免费软件靠志愿者的，没人逼我非得用这个。只是看起来，对于我这种程序员，用Mac OS当一个开发环境，也许还是奢望。

最后问题倒是解决了，用的是这里最下面给出的方法。也就是说如果错误信息给出提示需要你手动装什么，你就装，然后再fink install；如果没给出，那你只能碰运气去执行fink update-all，然后再重新执行fink install。确实比aptitude差远了，而且包也比较旧。

但我真的很喜欢那些华丽的玩意儿啊！！！

UW开发过一个叫pine的类似的东西，于是我google了一下它和mutt的比较，结果意外的发现了一个非常好笑但大概只有geek们才能看懂的笑话。我向你保证，这真的是个笑话，看到cat那句我就开始抽搐了。。。

“I use pico.”
“Hah! Pico. You are lame. Get a real editor, like emacs.”
“Emacs isn’t pre-installed on Unix systems. Real geeks use vi.”
“Oh yeah? I do everything with ed!”
“Well, **** that, I just use cat.”
“That’s nothing. I edit my system’s raw partition directly.”
“You’re not a real hacker until you’ve manually sent electronic signals with a couple of batteries over your keyboard’s wires by hand.”
“But you have to use a pre-fabricated power source. I shuffle along the floor and discharge my information through static electricity directly onto the wiretraces of my motherboard. And you have to be very skilled to not to cause ESD damage.”

Say if we want to prove A is true, we can suppose ~A is true, and try to find a contradiction.

Then according to some rules like ~A → B (≡ A∨B; the rule itself is true regardless of the truth value of ~A), we deduct that B is true by modus ponens.

However we then find B to be wrong (contradictory).  Then what makes us determine our assumption of “~A is true” to be false out of our instinct?  It turns out that the underlying logic is just another modus ponens:

   ~A → B ≡ ~B → A
   ~B
∴ A

I know I’m pulling hair but things can get really confusing when you delve into logic…

凡事就怕较真儿。。。连反证法都如此。

-D<localport>

Open <localport> on the client side. TCP traffic made to this port is forwarded through the secured tunnel between the SSH client and server.

-L<localport>:<host>:<port>

Open <localport> on the client side. <port> on <host>, which can be reached from the SSH server, is mapped to <localport>.

-R<serverport>:<host>:<port>

Open <serverport> on the server side. <port> on <host>, which can be reached from the SSH client, is mapped to <serverport>.
Draw some pics when you’re in doubt. And, use your imagination.

So basically the enhancements are:

1. Since f may accept more than one arguments, we can support it by
   1. lift_e returning stream of curried f, which can be fed to lift_e again repeatedly
   2. lift_e accepting multiple streams as arguments of f: e1, e2 …

   I have picked the former just because it was the first one came to my mind, and it sounds more reasonable. The latter implies a lot (probably meaningless) updates in the lifted stream.

2. When f is a function-valued stream, each time it updates, the lifted is also renewed.

/* f is a function or a function-valued event stream.
   e is an event stream.

   Returns a "lifted" function-valued event stream which consists of curried
   functions from f with values in e as the first argument.
   A new value in e (or f if it's a stream) triggers the new value in "lifted".

   Special work-arounds for empty values:
   1. If f is a function-valued event stream, every value in e before the
   appearance of the first value in f is ignored (since there is no function
   to "lift" them). In the future if f provides an initial value this can be
   patched.

   2. In the same vein, if f is a stream but its first value comes before the
   first value of e, no new value appears in lifted. Again, this can be patched
   of e provides an initial value.
*/
function lift_e(f, e) {

    /* Accepts a function of arbitrary arity and its first argument.
       Returns a curried version taking one less arguments. */
    function curry1(func, v) {
        return function () {
            var args = new Array();
            for(var i=0; i < arguments.length; i++) {
                args[i] = arguments[i];
            }
            // insert the new value in e at the beginning
            args.unshift(v);
            return func.apply(this, args);
        };
    }

    /* Uses func to "lift" e and stores the latest value in e to lifted.curValue */
    function liftAndStore(func) {
        e.listeners.push(
            function (v) {
                lifted.newValue(curry1(func, v));
                lifted.curValue = v;
            }
        );
    }

    var lifted = new Event();
    // TODO initial value of e should be put here
    lifted.curValue = undefined;

    if (f instanceof Event) {
        // f is a function-valued event stream
        f.listeners.push(
            function (fv) {
                // fv is a function.
                // A new function value in f triggers in lifted a new value
                // which is a curried function taking one less argument
                if (lifted.curValue !== undefined)
                    lifted.newValue(curry1(fv, lifted.curValue));
                // TODO need a better way to remove exactly
                // the previous function in f from e.listeners
                e.listeners.pop();
                liftAndStore(fv);
            }
        );
        // TODO if f has an initial value, liftAndStore it here
    } else {
        // f is just a function
        liftAndStore(f);
    }
    return lifted;
}

This has a flavor of mergeE since the resulting stream is triggered whenever f or e updates. Also, it can be seen as an operation satisfying the closure property (closure as in abstract algebra, not in programming langauges), or an OO decorator pattern.

In practice we can of course use the lifted stream in many different ways. Here for simplicity we provide arguments of curried f in a modified version of showStream called showStreamApplied, which delegates the presentation part to the former:

function showStreamApplied(e, args) {
    var appliedStream = new Event();
    e.listeners.push(
            function(fv) {
                appliedStream.newValue(fv.apply(this, args));
            }
    );
    showStream(appliedStream);
}

To show its usage I have made 3 showcases. Feel free to comment out some of them to observe individual output.

function loader() {
    // 1. curried functions in lifted do not need extra arguments
    showStreamApplied(lift_e(function (v) { return 10000 * v; }, timer_e(500)));

    // curried functions in func_e take (4-1)=3 extra arguemnts
    var func_e = lift_e(function(a, t, prefix, suffix) {
                            return prefix + t + suffix;
                        },
                        // every sec
                        timer_e(1000));
    // 2. feeding 3 arguments directly
    showStreamApplied(func_e, ['unknown', 'system time ', '.']);
    // 3. providing one argument by lifting again
    showStreamApplied(lift_e(func_e,
                             // every 5 sec
                             timer_e(5000)),
                      ['system time is ', '.']);
}

Note how first-class streams/behaviors objects in Flapjax hide callbacks away and make client code more lucid.
At last, you can see it run here.

Anyway, put this in your .vimrc and replace P4 and USERNAME with yours.

nmap e :call P4CurrentFile("edit")
nmap r :call P4CurrentFile("revert")
nmap d :call P4CurrentFile("diff")

function P4CurrentFile(operation)
    if !exists("g:P4WS")
        echo "Please set up P4WS first"
    else
        let l:p4cmd="!P4 -u USERNAME -c " . g:P4WS . ' ' . a:operation . ' //' . g:P4WS . '/' . bufname("%")
        execute l:p4cmd
    endif
endfunction

Now after setting your workspace and directory by

:let P4WS="YOURWS"
:cd YOURWSDIR

you can check out, revert or diff the file in current buffer with (without the double quotes) “\e”, “\r” and “\d” in normal mode. On my machine these are “,e”, “,r” and “,d” since I redefined the mapleader.