几天前, 偶然看到 SUN 公司 CTO Greg Papadopoulos 的 IT 产业红移学说. 慢慢思考, 做了很多笔记, 有几条写下来.

所谓的红移学说, 就是 IT 公司的计算能力需求是指数增长的. 这个结论没什么奇怪的, IT 产业的摩尔定律说, 每18个月微处理器的计算能力就能翻一翻了. 除此之外, 存储能力, 带宽需求等等, 都是指数增长的, 有供给就有需求,这一点原没有什么大惊小怪的.

但是仔细分析, 对计算能力需求的那些应用里, 是不是所有的需求都是同样的指数增长的呢, 不是. 那么, 有快有慢的时候, 就必然有超摩尔定律增长的和低于摩尔定律增长的. Greg 把超摩尔定律增长的定义为红移, 把低于摩尔定律增长的定义为蓝移. 并且从SUN自身角度指出, 为了让 SUN 跟上 IT 产业的发展大潮, SUN 必须找到那些超摩尔增长的子领域, 把产品销售给超摩尔的应用, SUN 才不会被摩尔定律谋杀.

Greg 的立论基于互联网带宽的超摩尔, 高性能计算需求的超摩尔和软件作为服务的超摩尔速度. 我个人的见解是, 至少目前有5+1 个领域是超 Moore 的. 第一, 复杂的关系计算的发展是超摩尔的. 比如 Netflix 的推荐系统, Google 的 AdSense 系统. 这些关系计算的增长速度, 是超过 2倍/18个月的. 处于提供这些服务的行业, 对计算能力的需求必然是超摩尔的. 因此, 他们必须购置新的 IT 设别, 更新软件效率. 第二, 海量数据的处理的发展是超摩尔的. 互联网数据目前的翻倍速度是 30%/年. 其他领域的数据也有如此的指数规律. 一般情况下来说, 这个速度是低于摩尔律的. 但是任何一家公司海量数据处理的, 都是从无到有发展起来的. 大如 Google, 也不敢说覆盖互联网所有信息. 因此在这十年中, 海量数据处理(特别是搜索, 爬虫, RSS) 将经历从无到有的过程, 其增长, 肯定是超摩尔 的. 第三, 海量带宽的发展是超摩尔的. 以 Flickr YouTube 和 Twitter 为例, 他们的带宽翻倍速度是以天为单位的. 在网络基础设施领域, 中国移动等网络服务商也曾超摩尔发展, 以此为契机很多网络设备服务商如思科华为都超摩尔发展的. 第四就是海量的交互是超摩尔发展的. 网游, 信用卡服务系统都是这方面的例子, 就不一一例举了. 第五可能不为大家熟悉, 就是海量的高性能计算. 这10年内, 世界超级计算机的发展速度是超过摩尔定律的. 在科研领域, 我们清楚的看到高性能计算的需求远远超过 Intel 每年提供的增长, 多达千个万个节点的超级计算机在美国的国家实验室已经很平常. 还有一个额外的是海量的多媒体处理, 全球的电影业, 多媒体业的发展, 横跨前面提到的五个上面, 对每个领域都有超过 摩尔律速度的需求.

这几年这几个子领域的超　Moore　发展, 造成了几个非常有意思的现象.

1 . Google 在超摩尔发展

Google 是一个及其有野心的企业. 首先, 它站在这个时代最快的超摩尔的领域, 海量数据的处理. 它同时还拥有复杂关系计算[Orkut, AdSense], 海量带宽处理 [YouTube] 和海量交互处理 [Talk, Gmail, Google Maps] 三个方面. 这个方阵中的每一个模块, 都是行业的翘楚. 各位读者应该在最近的三个月内都用过Google的不少服务, 而且使用Google 各项服务的总次数相比一年半前肯定是翻倍了. Google 的超摩尔发展和它的策略, 即整合人类所有信息并使之可用 是分不开的. Google 的心大, 舞台就大, 现在爬虫能爬到的信息, 远在人类可用信息之下. 因此, Google 为了完成目标, 必须远快于信息生产速度. 总有一天, Google 抓完了互联网, 增长速度和网络信息的速度一样了, 那Google 也就变为今天的微软了. 20年前或许一人一台计算机是最大的幻想, 谁能想到20年后整合人类信息是不是一定达不到呢. 不过 Google 是善于开创和培育新领域的公司, 因此至少在10年内, Google 依然会超摩尔发展下去.

2 . 超摩尔企业控制了整个产业的需求, 联盟的瓦解和重新结合是常态.

摩尔定律既规定了半导体企业的光明前途, 又是半导体企业的魔咒. 因为半导体的速度提高速度太快, 如果耗用半导体的应用没有发展起来, 或者在18个月内需求量没有更新一倍, 那么, 半导体和硬件制造企业就不会喜欢这样的公司. 想当年 Windows 如日中天的时候, 平均三年就推出一个新版本, 而且每推出一个版本, 能支持前一个版本的硬件都几乎不能完美支持后一个版本. 因此, 操作系统和应用软件在超摩尔发展, 反过来拉着 Intel 超摩尔发展. 而 XP 以降, 微软花了 5 年时间才更新到 Vista, 而且消费者还不喜欢. 个人计算机的增长速度和操作系统的需求速度已经慢于摩尔率. 这时候, Wintel 联盟的瓦解早就是预料中的事情了. 这时候 Intel 和其他硬件制造商, 不需要依靠微软, 也能存活. 为什么呢? 原因是, 他们在 IT 产业链中, 发现了除了软件企业以外的其他的超摩尔的东西, 这个东西, 就是上面说到的5+1, 而最重要的, 是网络计算.

3 . 传统软件企业被摩尔律超过

在解释网络计算之前, 我先解释一下为什么传统的软件企业被摩尔律超过. 一个产业, 如果不是新兴产业, 那么正常的发展速度应该是和国家的 GNP 发展速度相当的. 即使在发展速度最快的中国, 目前也只能做到 120% / 18 月. 这一点, 是摩尔律所不能容忍的. 软件产业, 和其他信息产业一样, 都是社会服务业. 其终极形态, 应当是和 GNP 发展等速的. 简单的说, 有多大的经济需求, 就有多大的软件服务需求. 但是, 产业从来就不是均等的. 当一项新的需求被发现的时候, 因为没有现存的应用, 巨大的需求缺口会拉着原本应该正常发展的产业超速发展. 比如中国的移动电话, 石油产业等等, 都是如此的例子. 在 70－90 年代, 所有的行业都在走信息化的道路. Office, 电算, 电子商务, ERP, CRM 等耳熟能详. 他们的需求缺口相比于产业所能提供的, 都是几个数量级的高. 这种所谓的蓝海让任何跳进去的公司都能发财, 而且发展速度都超过摩尔律. 在此情况下, 硬件企业作为市场的支撑, 也在蓬勃的发展. 到了1999年左右的时候, 互联网的第一次泡沫前, SUN, HP, IBM 等公司靠出售硬件, 大赚了一笔.

然而, 好景不长, 2000年问题解决以后, 发达国家原来轰轰烈烈信息化的公司基本上已经完成基础设施建设了, 软件的需求一下子放缓了. 电子消费品的出现使得个人电脑发展开始放缓, 各大公司因为网络泡沫的破碎也开始紧缩 IT 投资. 软件企业的需求在源头上被紧缩. 另一个致命的打击来自开源软件. 1999 年的互联网泡沫客观上促使了一样东西的普及, 就是开放源代码软件. 传统的软件企业的定价策略是一台计算机安装算一个价钱. 在互联网泡沫时候, 网站需要以超过摩尔律的速度购买计算机, 但是这样就会同样把指数级别的投资送给微软和 Oracle. 因此, 很多公司在购置硬件的同时, 缩减软件投资, 采用免费的开放源代码的软件. 这样, 软件的需求就是一个常数, 这一点一下子拉开了硬件商和软件商地位上的差距. 虽然互联网产业发展了, 软件公司却没有跟着超摩尔发展. 等到微软和 Oracle 等传统软件公司回过神来的时候, 超摩尔的互联网已经把他们扔在了车轮之后. 那么, 应对开源大潮和超摩尔的网络计算, 硬件公司在做什么呢?

4 . SUN, IBM 等硬件提供商放下身段生产平民硬件

如果我们观察从 99年到 2007 年, 这些硬件行业的大哥大做了什么, 我们就能清晰的看到一个个放下身段的巨头. 我们知道, 超摩尔的互联网必然以超过摩尔律的速度需要硬件. 哪个硬件商能赶上此大潮, 就能做弄潮儿. Intel 芯片商要做的, 是提供更加强力的处理器; 存储商做的, 是开发大容量的存储器. 而 SUN 和 IBM 这些系统商来说, 选择就是从阳春白雪走向平民硬件. 当年的 IBM 和 SUN, 固守自己的 RISC CPU 生产线, 投入大量资金开发专有 UNIX 操作系统. 昂贵的售价使得超摩尔的企业不愿采购他们的系统. 此时, 要不固守阵地, 要不另找出路. 我们看到, 他们都开始另找了出路: 出产便宜的基于 x86 架构的硬件, 支持开源的基于服务收费的软件. 他们知道, 只有把硬件做便宜了, 超摩尔速度才能眷顾他们, 否则出路就是 SGI 和 DEC. 只有把软件开源免费送出去, 超摩尔的软件需求才能最后通过软件服务的形式让他们受益. 而一个机器一份拷贝的那种传统软件商业模式, 已经不再实用. 短短几年内, IBM SUN Novel 包括苹果, 都拥抱开源, 拥抱 x86. 我想这不是没有原因的.

5. 如何抓住超摩尔律, 投入新兴 IT 市场?

A. 硬件

硬件厂商在这场互联网浪潮当中扮演了极其重要的角色. 首先, 他们联合了新兴的开放源代码社区, 透过降低了硬件系统的总体成本. 因为此, 硬件商既不需要自己投入大量经费研发软件并把成本转嫁给新兴产业, 又能避免自己口袋中的利益流向传统软件企业. 而网络服务商, 消费类电子制造商和设备提供商, 这些年都是活在超摩尔里的. 如 CISCO, 中国移动, Apple 都是时势造就, 不发财都不行. 当然, 硬件的制造需要较大的投入，除拥有一流的技术外, 尚需要一流的设计和制造. 目前这两点在中国都不具备.

B 软件作为服务/ 软件作为基础设施

前面已经提到传统软件企业, 比如微软, 正在被硬件厂商, 软件服务商, 开源社区合力绞杀. 那么, 做软件就不赚钱了么? 非也. 既然软件已经变成基础设施和服务, 那就应该发挥基础设施和服务的作用. 软件作为服务, 如 Gmail, Facebook, 如 Amazon 的 SimpleDB, 如 Google 的 Documents, 都作为某种服务提供. 前面提到, 因为软件不能按照一台机器一台钱卖掉了, 所以落后于 摩尔律. 虽然这么说, 实际上网络应用对软件的使用需求依然是超摩尔律的. 因为超摩尔的速度造成计算机数量的增长, 系统越来越大, 很多硬件瓶颈就随之出现. 这时候, 传统的单机软件无法解决所有的问题, 必须有一个支持大系统的软件系统出现. 作为提供给网络计算系统的软件, Google 是自产自销, 自己解决基础设施问题. Amazon 和 SUN 则是提供如 EC3, SimpleDB 等工具, 以便把超摩尔的需求转化为自身产品的超摩尔发展. 开源社区也分立出很多创业公司, 提供一揽子的软件解决超摩尔的方法.

我个人看好的是作为软件咨询和软件服务的服务提供商. 机会可以在提供海量信息处理系统, 提供海量带宽处理系统, 提供海量关系处理系统等方面入手. Amazon 的经验让我们看到, 这些软件服务都是可以从系统应用中剥离分立并且产品化的. 在面向互联网的软件服务方面, 我挺看好银杏的.

结尾语: 写完这些, 突然悟到, 所谓的蓝海, 不就是一个超过行业平均水平的新兴子产业么. 想要不陷入和 GNP 一样发展速度的的红海, 就要找到超过行业发展速率的新兴子产业.

[Disclaim: It’s evil, don’t use it unless you are fighting with some even more evil software.]

Short Intro. [Skip it if you don’t know much about OS or aren’t interested in the technical detail ]

As you might know, every program on Linux system runs on the kernel instead of directly contacting with actual machine. For modern operation systems like Linux, BSD(Mac) and Windows, a mechanism called system call is used to request the system resources via operation system so that operation system has the full control of all programs. In brief, when user program need call a function in library, e.g. print in stdlib, library function forwards (usually library function is a light-weighed wrap of the system call) the request to operation system. Since the system is highly hierarchical and user program is built on the top of libraries and OS kernel, it’s possible to insert some layers in between program and OS to intercept the request. Don’t panic about the nerdy name. Actually this strategy is commonly used on Window platform in anti-virus software as well, because anti-virus software want to monitor every system resource usage for any program and prevent the malicious resource requests.

Here, we simply want to intercept a system call named “TIME” so that every time a program request the current time (so that it can verify whether the licence has expired), we feed the program with a fixed (fake) time. By fooling the program around, you can literally use a program forever. God, doesn’t this mean I can use all software forever? The bad news is for some OSs like Windows, it’s very hard to do system call interception as all the APIs are undocumented and software might have other ways to prevent this. The good news is lots of software on Linux and Mac are simply reading system time. Actually, only top developers and Microsoft partners know how to do system interception. However, for Linux, since the system itself is open source from bottom up, there is no way to prevent such kind of interception (Now you know why some software companies don’t like Linux :).

Approach 

On Linux, tons of methods are around. Here I just introduce three of them briefly under the assumption that you don’t have the source code of that software. [Otherwise you can just modify the source code]

Method 1: Intercept library call in linking time.

Sometimes you have a library (A) that can be used as a part of your program and you want to intercept the library call of that library (A). The best way and the easiest way is to write a fake function and link it in the compile time. This method is totally harmless to your system and very neat. If you can do some modification in makefile, then this procedure is totally transparent to both developer and user.

Method 2: Intercept system call in the run time

If you’ve already got a execute program, then there is no way to intercept the system call in compiling time. To intercept the system call in the run time, there are two ways. The first approach is putting the target program in a designed container. Typically, a container fork/create/call the target program as child process. Since in OS, parent process has accessibility to the child process, it can intercept syscalls easily via ptrace toolset. The second method is to hack the kernel, namely, to tell the Linux kernel to response syscall in a certain way. Since now Linux supports kernel module, a very convenience approach is to compile a program as kernel module and install it on the fly. However, this method is less flexible then the previous method as now all the syscall are intercepted, even for system calls from other programs. [Sure, you can restrict the module only applicable to a certain process via a pid comparison, but then you need to feed the kernel module with PID, it’s awkward ]

In my implementation, I use ptrace/container method. I’ve tried kernel module method but failed as there were not so much well-formed documents on Linux 2.6 kernel.

Here is my code, it’s self-explanatory, have fun with hacking. [Download the C file]

/* Faketime wraps a user program and feed it with user-specified fake system time
   so that it can be used forever without any “licence expired” problem
	 
    Copyright (C) 2007 Eric You XU, Washington University ( youxu [@T] wustl.edu ) 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 

*/

#include <sys/ptrace.h>
#include <asm/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/syscall.h>
#include <linux/user.h>

/*
Register layout defined linux/user.h, but actually in 
 asm-$(arch)/user.h
struct user_regs_struct {
        long ebx, ecx, edx, esi, edi, ebp, eax;
        unsigned short ds, __ds, es, __es;
        unsigned short fs, __fs, gs, __gs;
        long orig_eax, eip;
        unsigned short cs, __cs;
        long eflags, esp;
        unsigned short ss, __ss;
};
*/

/* Note that EAX now is RAX in x86-64
 	we can also find the actural offset for any register
 	from <asm-$(arch)/ptrace-abi.h>
#define RAX 24
*/

#define ORIG_RAX 44
/* ORIG_RAX stores the number of syscall */

#define SYS_TIME 13
/* Machine specific syscall number is defined in 
	unistd.h */

#define back_to_future 1175737392

/* Time is stored as a long interger in C, you can get 
	current time via time(NULL). Thus, it’s very easy to 
	get a long integer denoting some time in the past. 
	
	Python/Java can also be helpful in figuring this out 
	
	If you don’t know how, just keep in mind that 
	Dec. 1, 2007 is about 1196476452. 
	One day interval = 60*60*24 = 86400 [Time flies fast]
*/

char* host_program = “your program name here”;
char* arglist = “your program fake list here”;
/* Make modifications for these two lines, then 
	compile it via
		gcc faketime.c -o faketime
	use it via 
		./faketime
*/

int main()
{   pid_t child;
    long orig_rax, eax;

	 struct user_regs_struct regs;
	 int status;
    int insyscall = 0;
    child = fork();
    if(child == 0) {
        ptrace(PTRACE_TRACEME, 0, NULL, NULL);
        execl(host_program, arglist, NULL);
          }
    else {
       while(1) {
          wait(&status);
          if(WIFEXITED(status))
              break;
          orig_rax = ptrace(PTRACE_PEEKUSER,
                     child, ORIG_RAX, NULL);

          if(orig_rax == SYS_TIME ) { /* Intercept SYS_TIME syscall */
             if(insyscall == 0) { /* Syscall entry */
                insyscall = 1;
             			  }
         	 else { /* Syscall exit */
					ptrace(PTRACE_GETREGS, child, 0, &regs);
				   	/* We can also use ptrace(PTRACE_SETREGS, child ,RAX, &back_to_future); 
						but it doesn’t work. There might be some tricky here */
					regs.eax = back_to_future;
					ptrace(PTRACE_SETREGS, child, 0, &regs);
            	                 }
          } // End if with SYS_TIME 
       ptrace(PTRACE_SYSCALL, child, NULL, NULL);
        }
    }
    return 0;
}

我一直很推崇使用 Python, 但是推崇不是迷信, 今天就说说几个 Python 相对于 Java 和其他语言的缺点, 以及初学者要注意什么.

1. 文档不完善, 最少惊奇原则不适用

很多 C++ 和 Java 开发者都知道, MSDN 和 Java Doc 堪称技术文档的典范. Java 更是充分体现 Knuth 提出的 Literate Programming 的精华, 用一个专门的叫 javadoc 的工具自动提取程序元信息, 生成交叉引用的 JavaDoc 文档. 任何复杂的类, 框架, 在javadoc 的统一管理下, 可以生成非常漂亮的文档. 如果再配合设计模式中的 facade 模式, 一个复杂的框架很简单就可以上手. 这方面, Hibernate, Lucene 都是优秀的典范. 当然, 交叉引用的文档也有明显的缺陷, 就是极其庞大冗长, 因此 JavaDoc 和 JDK 是独立的两个部分. MSDN 更加绝了, 直接出几张光盘, 你爱装不装. 虽然冗长, 好处就是在面向对象的汪洋大海中顺着链接, 永远不会丢失. 而 Python 的文档还远远不够细致. 所有的对象方法, 只是简单介绍. 如果一个对象方法返回另外一个不熟悉的对象, 则必须手工定位新对象的位置, 而不能顺着文档继续前进. 为了搞清楚一个包, 完成一个小任务, 可能要多次搜索文档. 对于黑客级别的用户来说, Python 文档言简意赅, 喜闻乐见, 只要记住了每个对象的每个函数, 写程序如行云流水. 对于初学者和用 Python 写稍大项目的人来说, 这就是最恐怖的噩梦. 因为以介绍单个函数功能为组织方式的文档, 对于刚上手的用户来说, 很难顺着对象调用关系，通过文档指引完成任务. 即使著名的框架比如 django, 也缺少交叉引用的细致的文档. Python Library Reference 只能说是一个完成了 50% 的README. 在这种情况下, 除非对一个框架很熟悉, 否则这个框架对于初学者来说简直是”惊奇的噩梦” — 一般用户只能看例子然后顿悟到: 哦, 原来是这样用的.

除此以外, 因为语言的动态性, 使得 IDE 能给的帮助特别少. 对于 Java 程序员来说, 很多时候都是靠着 Eclipse 的提示去选择正确的方法调用. 而因为 Python 的动态性, 变量的类型到运行时才能确定, 因此能够给的提示相对变少. Python 既是动态的, 又是强类型的, 所以代码的阅读者必须要一步一步手工追踪中间对象的类型, 并且查阅对象方法文档, 才能搞清楚到底一段代码做得什么. 而这一切, 偏偏是没有 IDE 帮助的. 对于开发者来说, 如果不熟悉对象的可用方法, 用 Python 开发也会事倍功半, 因为要常常停下来去 Google.

当然, 文档不够完美, IDE 不支持的现状, 根本是因为 Python 的动态性: 谁让 Python 返回值不规定类型呢? 我的建议是, A. 对于现成已知的一些对象方法上, Python 社区应该注意文档的维护. B. 对于不熟悉对象的可用方法这个问题, 要买一本 Pocket Reference. 或者下载一些 cheet sheet. 在刚接触 Python 或者 刚接触 Python 框架的时候, 一本薄薄的可供快速查阅所有对象的所有方法的小书, 无比重要. 这也间接的说明, 和 shell 脚本, 正则表达式语法等一样, 脚本语言必须要很熟悉才能发挥魔力.

(– 附实例，对Java 不熟悉的可直接跳过: 我曾经做过一个游戏, 这个游戏类似于推箱子, 其中的一个核心是要把多幅带alpha 通道的图像拼成一个图像, 然后显示在窗口中. 打开 API Doc, 简单的搜索一下, 发现有 java.awt.Image 类. 不过这个是抽象类, 没关系, 文档下面就明明白白写着两个可以直接用的类, 一个是 BufferedImage, 另一个是 VolatileImage. 看上去 BufferedImage 更像, 于是点进去, 正是想要的. 看看构造函数, 一个空白的图像就构造好了. 顺着方法向下看, 看到 createGraphics() 方法, 返回 Graphics2D 方法, 说明中写着这个可用做在 Image 上绘图, 正是想要的, 点返回值, 是 Graphics2D, 有方法叫 drawImage. 任务完成, 轻松自然.

回到 Python. 我遇到过一个需求, 是用 Python 提取所有一个 Zip 文件的注释. Google Zip+Python 定位到 zipfile 模块. 找到 ZipFile 对象. 读文档没发现可以往外读注释, 只能碰运气, 开一个解释器尝试. 看上去 getinfo 可以. 因为没有交叉引用, 只能搜索ZipInfo 这个对象. 终于看到一个方法是 comment. 不知道类型, 仍然需要自己在解释器下先 type 测试一下, 才能在程序中写下一行完整的语句.–)

2. 文档上有, 但是你不能用

我用 Ubuntu/MacOSX系统, Python 是自带的. 以为万事大吉, 实际上, 因为 Python 所有的库都是运行时装载的, 所以有些库在有些系统上是缺失的, 而文档则是所有标准安装的超集. 因此即使文档上有, 你也没法用.

这个问题对于 Java 程序员和 .Net 程序员来说是不能接受的. 对于任何一个良好设计的 SDK, 文档和实际可用的应该具有同等的覆盖面. 在 Java 中, 有一个包就是有, 没有就是没有, 绝对不会出现标准文档中提到了, 实际中却不可用的情况. 对于可选包, 用户也能理解需要下载模块. 而对于 Python, 开发人员很难理解为什么标准文档中提到了, 实际中却缺这个组件缺那个组件. 一个潜在的伤害就是, Python 的跨平台能力没那么强. 试想, 开发的机器上有一个模块, 而用户没有. 而标准文档偏偏又认为这个是一个标准组件, 那么, 在装载的时候，找不到这个组件了, 让用户根本就无从下手. 我的建议是 A. Python 应当有更好的 import 报错机制, 对于不是每台机器都安装的模块, 应当给出平台中立的更加友好的帮助信息, 而不是简单的 ImportError. B. 应当在 Python 语言中支持更加强大的内省机制, 对于系统当前可用的包, 应当有一个全局的缓存. 这样, 用户才能知道哪些可用哪些不可用, 不可用的时候怎么办. C. 对于用户来说, 只能求助于Google 或新闻组, 或者从 Python 源代码中找线索. 一个较好的办法是在 Python 源代码上 执行 make test, Python 会汇报哪些模块已经编译, 哪些模块被跳过了.

(–实例: 前几天想写个程序抓Google Reader. 认证的时候要用到 SSL. 因此找到 Python 文档, 照着例子 import urllib2, 然后直接连 Https 服务器. 出错了, 原因是没有 ssl 支持, 不能访问 https. 所有的 Python 在线文档都说, 这个是标准模块. 对呀, Python Library Reference 里面都有的模块, 怎么能有问题呢? Google 搜索也帮不了什么忙, 因为 Python 是跨平台的, 不同的平台有不同的解决方法. 所有的在线帮助只能提示到 _ssl.o 这一层. 于是, 只能翻看 Python 源代码, 在 Modules/_ssl.c 中看了一圈, 发现需要 openssl/ssl.h 等文件, 这才意识到, 需要安装 openssl 和 libssl-dev. 在 Ubuntu 上, 同样的问题还存在于 sqlite3 模块, tk 模块 和 bz2 模块. 分别需要安装 libsqlite3-dev, tk-dev 和 libbz2-dev, 再重新编译 Python 系统. 使用 make; python setup.py install 来安装 –)

3. Python 是胶水语言, 用是简单的, 模块开发是痛苦的

Python 用到一定程度以后, 一个自然的需求就是把其他语言, 特别是C语言写的库包装成 Python 库. 这个问题说复杂也不复杂, 在 Python/C Reference Manual 中也提到了所有必要的信息. 只是层次太细. Boost.Python 有更加好的实现, 不过需要对 C++ 模板很熟悉才行. 当然, Python 的模块开发的痛苦比起 JNI 复杂的 JNIEnv 对象, Lua 的 基于栈的 Push Pop 已经是大大轻松了. 相比较于 Ruby 的自动生成 makefile, 也算各有千秋. 只是模块开发设计到的技术细节太多, 要对 Python/C API 了然于胸才行. 因此我的建议是: 不要从轮子造起. 如果有这样的模块, 就用. 如果没有, 而又非要用特定功能的模块不可, 那就暂时先不要考虑用 Python. 相比较于其他更加成熟的语言, 比如 Java, Python 的可用模块还是显得少了一点. 因为 Jython 的出现, 这个情况已经大大缓解. 不过工业界历来喜欢用最稳定的东西, 所以可以想象, 多少 Web2.0 公司是为了用 Lucene 才用 Java 服务器的, 而每天又有多少新的公司投入 Java 的怀抱 :)

A little bit history

Being in the academical area for years, one of my dreaming tool is an online collaborative paper reader . You can say it’s YouTube with documents, or Digg with pdf files–name actually doesn’t matter. The ultimate goal for this system is to support collaborative document reading/organization for professors and Ph.D. students. Since we now have Ajax (more interactive than before) and Flash(as powerful as PDF), I would expect an light-wighted solution. arXiv and Citeseer do really good jobs in storing and linking all the documents, but the ultimate goal for me is to read.

On winter 2006, I expanded my ambition to a larger project: read the f source code and read the f books (Here of course the f word means fine :). I launched my domain name rtfsc.org [now redirected to Apache.org]. Our team members thought that rtfsc was easier than rtfm because we only need to deal with text information instead of PDF file. However, we set ourselves on the wrong track. It turned out that if we let the users upload and update their codes all the time, we have to implement a Subversion or even a Sourceforge. For us, an online code-reading community without code management and code search is terrible, but we don’t have that much time to finish all these ambitions. The other obstacle comes from my lacking experiences of Ajax development. Anyway, at last, we gave up. We stopped the development after Christmas. On that week, I was the person of the year 2006.

New motivation

I have been thinking about this project for nearly one year without any action. Lots of similar projects were there during this year, for example, flashpaper, edocr and scribd. But none of these are my dreaming tool. I took a retrospect about our project again and found that nobody actually wanted to do that except us because they didn’t actually understand our requirements. Their goals are usually becoming the next DocTube thing, while my goal is to have a handy system open for academical research. Also, I found some open source tools that were really inspiring. These make me interested in the project again.

Technical aspects:

1. PDF to SWF is not so that hard, there is an open source tool: PDF2SWF.

2. I thought that I can’t control the converted SWF as there is no API exposed as Flashpaper, but I was wrong. Actionscript can control it directly. What I need to do is to learn Actionscript, which is not so that hard.

3. I was thought that Flashpaper use some undocumented APIs which we could never know, but I got SWFmill today and now I can study the code of Flashpaper. [Disclaimer: I didn’t say anything about how to decompile flashpaper or violate the EULA of flashpaper]

4. I thought Ajax + Flash development was hard and had a very steep learning curve, but again I was wrong. On hacking Google Finance these days, I found the Flash Ajax Integration Package, which is very handy to use for some newbie like me without any Ajax/Flash developing experiences.

Proof of concept

Here is a proof of concept product. I convert my PDF version CV to swf and then combined it to a controller I wrote based on the default controller provided in PDF2SWF. (This CV has two pages, you can proceed to next page by click the red arrow)

cv.swf

Final Word

What I need is an sophisticated viewer which can be as powerful as flashpaper can communicate with other Ajax components on that webpage. So for developers, if you find this idea interesting and you are good at Ajax/Flash, feel free to take this idea and do it, as I might not have time to do it or it will take me a long time to finish it. I desperately need an Ajax style flash-based document reader with inline comment support. If you can do thing and get your own startup based on the idea, my only request is letting me be your user.

BTW, if there was some lessons in this project, I would say, choose the handy tools before you get start.

[Keywords for search engine: Ubuntu dell vostro 200 live cd can’t boot harddisk]

Make sure add “irqpoll” as the kernel parameter, i.e. :

title           Ubuntu gutsy, kernel 2.6.22-12-generic (recovery mode)
root            (hd0,0)
kernel          /boot/vmlinuz-2.6.22-12-generic root=UUID=78dea514-8cc8-40a9-9e51-13c359bc681b ro  quite splash irqpoll

initrd          /boot/initrd.img-2.6.22-12-generic

These are cited from here.

When the PC boots up, you will see the Grub countdown, which is set to 3 seconds by default. Press “Esc” to intercept this countdown and go enter a Grub menu. Then

• Press ‘e’ to start editing.
• Scroll down to the “kernel…” line. The is the line that tells Grub which kernel to boot with and the parameters to be passed to the kernel when it boots are placed at the end of this line.
• Press ‘e’ again to edit this line.
• Move to the end of the line. You will see any existing parameters and can add other new parameters to the end. [Add your irqpoll here]
• Parameters are separated by spaces and are mostly either a single word (e.g. nolapic), or an equation (e.g. acpi=off).
• Once you have added the parameter to the end of the line, press Enter to accept the editing.
• Then press ‘b’ to boot using that kernel and those parameters.

Then, go here to see how can you modify the parameter permanently.

Here is a quite funny picture I found today on digg. It is called the Best Phishing Email, Ever. Despite the funny nature of this hilarious letter, have someone really noticed that in this letter, we have G mail or Gma il instead of Gmail? (one extra blank in between the letter “G” and “m”, or “a” and “i”).

Last year when I was interviewed in Google, I reported this bug to Gmail team, (Sadly to say, they didn’t take it very serious, as it’s still there now). Maybe they can argue that it’s a feature, but let me take five minutes to explain why is it. (I guess it’s fairly simple and straightforward).

Let’s start from a little background about HTML. We all know that when we send colorful texts like “Google” via gmail, the email format is actually HTML. Here is a quite important aspect about HTML: An HTML user agent should treat end of line in any of its variations as a word space in all contexts except preformatted text.(Page 20, RFC1866) That is to say, a cstring in HTML source file like “a\nb\nc” will have the redering output identical to “a b c”. Therefore, it’s really confusing that we have to use <br/> to make a newline within a paragraph in HTML text, and “\n” is equivalent to a white space in most of the cases.

Now let’s go back to Gmail. When I send myself a piece of email with a colorful string “Google” via Gmail, I got “Googl e“. Via viewing the source of the HTML, we can actually find that there is a “\n” in between those letters. For example, this is a piece of HTML(javascript) excerpted from Gmail source related to this colorful Google:

\u003cfont color\u003d\”#000099\”\>G\u003c/font\>\u003cfont color\u003d\”#ff0000\”\>o\u003c/font\>\u003cfont style\u003d\”background-color:#ffffff\” color\u003d\”#ffcc00\”\>o\u003c/font\>\u003cfont color\u003d\”#3333ff\”\>g\u003c/font\>\u003cfont color\u003d\”#33cc00\”\>l\u003c/font\>\u003cfont color\u003d\”#ff0000\”\>e\u003c/font\>\n \u003c/div\>\n\u003cdiv\> \u003c/div\>\n\u003cdiv\>

Here \u003c is “<”, \u003d is “=”, without the bold “\n” in this line, the result should be “Google“. So, why we have an extra “\n” here? Who did this trick? The answer is simple: “Gmail”. For some reason, Gmail breaks a long line in HTML source file into multiple lines and sends the email out (I haven’t figure out the rule that Google uses to break lines in HTML source file). By doing several trival experiments like sending mail from Gmail to Hotmail and vice versa, I am now pretty sure the problem is caused by Gmail automaitc line breaking strategy. That is to say, Gmail client automatically inserts a newline(”\n”) symbol in the HTML source file and causes this “visual bug”. Actually this bug is quite easy to fix, for instance, just break the line at the first blank after the label name, for example, like:

<span
style=”color: rgb(255, 0, 0)”>red</span><span
style=”color: rgb(0, 255, 0″>green</span>

instead of say

<span style=”color: rgb(255, 0, 0)”>red</span>
<span style=”color: rgb(0, 255, 0″>green</span>

or

<span style=”color: rgb(255, 0, 0)”>red</span><span style=”color: rgb(0, 255, 0″>
green</span>

The first generates “redgreen“, and last two give “red green”

BTW, here is a nice tip for interviewees: love your prospective employer, love their products. Eventually, you would have a very nice understanding about their culture and products. All companies are willing to hire guys who actually love their culture and products (and can even find bugs :).

PS: in preparing this article, I found that Gmail team has secretly updated the text format system from using plain old <font> to fancy (and elegant) XHTML+CSS <span>.

PS2: http://www.opinionatedgeek.com/dotnet/tools/Base64Decode/Default.aspx is a nice online tool for decoding the base64 format.

前几天就听说国内邮箱往国外发信出了点问题. 我今天也收到了第一封这样的邮件. 其实挺鄙视这些纸老虎的, 一点技术含量都没有.

上次看到一个”最牛B的共和国卫士“, 于是看到了所谓的HNC, (Hierarchical Network of Concepts), 懂自然语言处理的人一看就知道其实是POS+基于规则. 不知道新语丝有没有兴趣对大正公司的 这套工具打打假. 骗了国家多少血汗银子, 做出了一个极其 SB 的墙. (提示: Google 搜索该英文没有任何其他学术研究, 就是一圈人自娱自乐). 做墙就做墙, 得严肃点专业点, 得符合科学发展观. 搞个没技术含量的伪科学的墙, 简直破坏国家形象啊. 我都替胡主席着急, 毕竟也是关系国家安全, 十七大顺利召开和我党生死存亡的大事!

PS: 最近没什么时间捣鼓这些. 等有时间, 我得好好弄一篇充满对立立场但是就是不撞墙的文章, 来证明所谓的墙, 其实就是纸老虎.

谁比Google 懂中文?

一年前, 你要是问我这个问题. 我会小心翼翼的说: 在某些关键词上, 百度质量稍微好一点. 但是Google 抓的双语网页和英文网页多, 在其他关键词上Google质量好, 两家各有仲伯, 不能说谁更加懂中文. 为此我还专门写了一篇文章帮大家评判什么是懂中文.

可是现在, 你要是问我这个问题. 我会毫不犹豫的告诉你: 比Google 更懂中文的公司诞生了. 其名字是两个字: 不是雅虎, 不是中搜, 不是搜狗, 不是有道, 不是天网, 不是百度, 不是汤姆, 答案是: “!!!谷歌!!!” (嘹亮的山谷之歌响起)

不信? “《财经》杂志封面报道：谷歌重来”一文中, 有段对谷歌技术总监王劲的采访, 原文如下:

“美 国工程师不懂中文，无法准确分词，常常造成可笑的问题。”谷歌中国技术总监王劲说。比如，用户输入“电脑”两个字，正常的情况是，页面左侧应出现电脑的搜 索结果，右边应该出现电脑产品广告，但美国工程师不懂中文，可能会把“电脑”分成“电”和“脑”两个字，出现的结果和广告是关于“电”和“脑” 的，令人啼笑皆非。

虽然我无法确定百度和Google 之间谁牛, 但是瞧瞧人家谷歌, 把多差的一个Google”汉字”搜索引擎变成一个多好的谷歌 “汉词” 搜索引擎啊 (Tinyfool 对此句亦有贡献). 谷歌青出于蓝, 十八个月以来终于让 “电脑” 不是 “电”+”脑” 了, 多么大的成就啊! 谷歌的确比Google懂中文, 这下大家相信了吧?

或许在中国把 Google.com 转到 谷歌 是有道理的, 人家比Google 更懂中文, 你们咋不用呢. 咋不知道体会人家的良苦用心呢? 下次谁再说 Google 懂中文, 请自费到中关村谷歌大楼外面壁.

相关文章:[伟大的谷歌]谷歌技术人员成功将google汉字搜索引擎进化为汉词搜索引擎

// 我有时间了得写个英文版, 让全世界人民, 包括Google总部的所有人, 看到我们 谷歌 在中文搜索上做出的杰出的贡献.

Update:

对于中文分词我是只听过, 没做过的门外汉, 不过我发现了一个测试Baidu 和 Google 搜索引擎分词结果的简单实用的方法, 对于想测试他们分词性能的人可以尝试一下, 不知道这个是不是我先发现的:)

对于百度, 最近百度出现了快照, 只要把鼠标停到网页快照的链接上,浏览器状态栏就会出现一个链接。这个链接中你会发现关键词被用分号隔开了， 而这个就是分词结果。 比如说,我搜索: “百度不懂中文分词算法”这个关键字,百度切分成了 “百度；不；懂；中文；分词；算法” 而且从最后快照上面的提示看, 百度把“分词”这个词和前后都重新组成了一个新词.

百度 不 懂 中文分词 分词算法

对于Google 要相对麻烦一点, 同样还是用快照(可能大陆不能用), 点快照进去后, 不同的颜色就是分开的词, 比如说:”谷歌不懂中文分词算法” 被分成了这个”谷; 歌; 不; 懂; 中文; 分; 词; 算法”:

就这个例子看, 谷歌的工程师可能不光把“电+脑”组合成”电脑” 就结束了, 起码要把 “谷+歌” 变成完整的 “谷歌”, 把”分+词” 变成完整的 “分词” 吧. 或许这个例子的象征意义远大于它的实际意义. 谷歌在本地化的路上不是比美国工程师多解决了一个”电脑”就行的, 还要解决”谷歌”和”分词”

我只是抛砖引玉，各位研究分词的高手可以评判他们的优劣.

我有5个电子邮件地址，工作上用wustl.edu的，私人用gmail的，当然最后都是用Gmail收取. 以前没啥保护意识，乱公布邮箱，现在每天至少90封垃圾邮件. 因为我的用户名中间有个”.”, 而且都不是英语单词组成, 有些字典攻击的Spam根本就打不到我, 所以相比较而言还不是Spam最严重的目标.

用了好久Gmail, 其垃圾邮件过滤的确是非常好的. 我印象中只有一次False Positive (把正常邮件Spam了)，这还是因为那封邮件只有一个hello 和一个图片造成的。按照我的经验, Gmail 识别成False Negative(垃圾邮件识别成正常的) 有以下几种,

1. 像模像样的中文（非英文）邮件 （至少遇到十次）：

> 贵公司（厂）财务负责人：
>
> 您好！
>
> 本公司是一家专业为国内外企业提供专项经营服务的股份制企业，可为各类企业代开各种发票，（主要包括：广东省及国内各省统一商品发票、增值税、机械、建筑、广告、运输、服务、税务代开类等发票），公司的客户遍布全国各地，本公司一贯以”诚信、高效、务实”的经营理念和”稳妥、快捷”的经营作风，不断地锐意进取、与时俱进，竭诚为全国各地有需要的客户提供更加全面、更加到位的服务。热忱欢迎您的垂询！！
>
> 顺颂商祺！！！

本来Gmail对中文支持就不好，更不说垃圾邮件识别了。况且这些邮件实在太不像垃圾邮件了。当然这种垃圾邮件有个致命问题，就是有些关键字，只要设置一个 “发票” “财务负责人”， 基本上就可以过掉。(初期我搜”发票”不能定位到这个邮件，也难怪Gmail识别不出来)

2. Gmail 初期, 改换的关键词, 比如把Software 写成 S0ftware （现在基本上没有了）

Need S0ftware?
OEM software - throw packing case, leave CD, use electronic manuals.
Pay for software only and save 75-90%!

Discounts! Special offers! Software for home and office!
TOP 1O ITEMS.

$79 Microsoft Windows Vista Ultimate
$79 MS Office Enterprise 2007
…

3. 啥文字都没有，含有几个外部图片链接
这些邮件的图片链接是动态内容，也就是说，如果你向那些地址请求图片，spammer 就会知道这个邮箱是有效的，然后，垃圾邮件就会更多。又一次我为了”让垃圾来的更猛烈些吧”，特地把那些图片链接都一一分析了一下, 结果可以想象是垃圾果然更猛烈了……

这段时间大部分的没识别出来的垃圾邮件都是这样的形式，Gmail 基于文本过滤的系统目前没法过滤出来，大约50％的这些邮件往往都在我收件箱。如果都用外部图片的话，虽然Gmail可以不显示图片，但却还是不能识别这些垃圾邮件。至于具体怎么弄，各位读者有没有什么好办法？

如果大家对Spam过滤的研究感兴趣，可以读著名的Essays 系列 (Google:Essays 第一条结果) :

http://www.paulgraham.com/antispam.html

Spam过滤是本质上是Turing Test 问题 (区分人和机器), 因此不要过高期望Spam能够100%被挡掉。但是简单的往往是最好的，基于文本的Bayesian分类器已经非常之强大了, 如果你想到了OCR方法, 我还是劝你暂时先放弃这个吧. 说不定等Google能在图片旁边放AdSense的时候，你再来研究这个 :)

Spam有时候也能变成黑客搞笑的东西，比如说

Google Blogoscoped 就写过一个 十大对付Gmail Spam的办法 , 包括火烧，送Bill Gates 等等。可谓Spam十大酷刑。
当然也有现代派的人把 Spam的标题串成诗的 .读起来比梨花体好多了. http://www.spam-poetry.com/
GNU也有经典的Spam Joke: http://www.gnu.org/fun/humor.html#TOCSpam

PS:
我倒是想，要是我和各位读者说，如果你要给我发邮件，请在邮件中包含一行这样的字符:
5^&&(&*@29bd8067ab0c822cc@)$*@)!$*)@56f485fbd675544ba69d5ec($*#&$@&#@(!
或者我自己从dev/random 拿个串来过一次sha1sum, 把这个串做成我Gtalk/MSN/Email 签名档让大家都能看到。然后我用Gmail Filter, 不含这个的通通Spam, 我就不信Spam 就这么强大，哼哼！

当然，此建议因为强烈不切实际而没啥操作性～～

读前提示：作者并不是搜索引擎和语言处理方面的专家，对自然语言和搜索引擎的理解仅限于读过的十几本书和五六篇论文，对于该领域的理解水平相当于普通计算机专业研究生。作者的观点可能带有主观看法。另外，本文不试图评价哪个更懂中文，只想告诉大家什么才是计算机领域所说的懂中文，免得简单的因为名字起得不好或者打错了字就说不懂中文，或者第一页是广告就说不懂中文，那样就有点好笑了。

先说几个标题, 都是关于懂中文的。 谷歌不太懂中文 百度真的比Google更懂中文么?, Google真的不懂中文? 雅虎比百度更懂中文 还有 百度，你只懂中文 ；作为普通的用户，不知道看到这些眼花缭乱的宣传会不会头晕。而且这些Blog文章，往往就是标题党，拿着一两个小点就开始发挥，而实际上有些并不是懂不懂中文的问题。因此，我在此写一个简要的介绍，告诉大家什么叫懂中文，免得以后看到类似的标题也高不清楚谁对谁错。

首先，人是评价技术的主观标准，如果一个中文搜索引擎给你的感觉是结果不好，无论是广告多了，排名靠后， 结果不相关，还是分词不对，它就是不太懂中文，这个标准是肯定的。但是，这个标准并不是全面的客观的。

我想解释一下，对于搜索引擎，什么叫懂中文，我们用什么样的客观标准去评价”懂中文”.

要强调的是：搜索引擎定义的懂中文和自然语言处理定义的懂中文是不一样的

我们知道，中国人都懂中文（当然少数民族不说汉语的咱不讨论）。懂也就是说能理解中文的意思，不管是不是文盲。我们说某老外懂中文，是说他能理解中文的意思。同理，计算机懂不懂中文，关键是计算机能不能理解中文的意思。计算机自然语言处理的本质，是对句子或文章进行词法分析（哪几个汉字是一个词），句法分析（好比说 主谓宾），语义分析（句子是什么意思），最后把汉语变成一种中间语言，或者一种叫语义网络的东西。 人可以验证计算机生成的语义和我们想表达的语义是否一样，从而验证计算机是否懂中文。

而搜索引擎定义的懂中文，不是理解中文的意思，而是决定能否由中文关键字得到想要的结果。 搜索引擎通过抓取网页或其他资源，编制索引，而用户输入关键字，则可以取出匹配的结果。因此，搜索引擎的懂中文可以理解成这几个方面：

1. 能否正确抓取中文网页
这一点的是评价搜索引擎中文质量的一个标准，但是并不是评价懂不懂中文的好标准。
首先，如果是蜘蛛抓取的面不够广，我们可以说这个引擎最终质量不一定会高。但是不代表这个引擎不懂中文。比如一个人收藏了很多书签，每次从书签中返回一个结果给我。他就是一个智能但是搜索面很窄的引擎。当然，如果一个蜘蛛蠢到不能应对多种汉字编码，那么，的确可以说不懂中文。

2. 能否正确编制索引
这一点牵涉到两个方面，一个是分词，一个是索引，其中分词是评价一个搜索引擎懂不懂中文的很好标准。
什么叫分词呢，我们知道，英语单词与单词之间是有空格的，因此字母是字母，词是词。但是中文很不一样，有个笑话说：老师让小明用 如果造句，小明说，汽水不如果珍味道好。如果搜索引擎把这个句子断成这样，其结果的质量可想而知。这个例子当然和极端，但实际上搜索引擎不会分词的现象普遍存在，比如 live 搜索共和国家，第一条结果就把” 和 “分成一个词了。 yahoo第一条也不对。再看看Google 的第三条也不对。相比之下， baidu 分词完全正确，分成两个词。当然具体的结果相关性在这里我们先不讨论。分词，有时候也可以理解为 能否正确辨认用户输入关键字，在搜索网页时候结果可能受排名影响而不容易看出优劣，但在小结果集合中效果明显。比如 地图分词， 邮件搜索分词，站内搜索分词，这些结果如人饮水，冷暖自知，大家可以客观的评价。至于百度的广告： 我知道你不知道我知道你不知道我知道你不知道我知道你不知道，只是表示他有中文分词／句能力，并不一定表示百度真的能把这句话理解。（我认为这句话存在不可判决路径，连人也可以分出几种意思，计算机又怎么可能分对？）

第二是索引，现在的搜索引擎，在链接下面往往会有一些小的片断帮助你筛选信息。实际上，这些小片断的选择很重要。 Microsoft Research 就曾经做过一个研究， 根据这些小片断做聚类。 小片断的好坏实际上表现了搜索引擎对这个关键字的理解。我们 可以用八荣八耻做测试，看看哪个能在小片断中体现相关信息。但是讽刺的是，恰恰是 live 的小片断的质量最差，有些片断和八荣八耻无法关联。Google, baidu 和 yahoo 小片断质量类似，其他关键字我未尝试，此处仅为一例，不作为论据。

3 . 能否正确输出匹配结果
Baidu 饱受诟病的一个原因就是竞价排名影响结果。其实这也是一种商业模式。但是这个模式不可避免的影响了结果。相当多的人在此批评百度不懂中文。客观的说，懂不懂中文和这个关系不大。不过减去广告后的比较的确很有价值，也的确能说明问题。有些文章写的很客观，有些纯粹拿着一个点发挥。

4. 扩展一：能否自动对大规模相似文本聚类
这个主要用在新闻上， baidu 的新闻质量和 Google 的新闻质量都很高，这方面尚未有任何比较，如果下面再有文章关于这个，相信大家有自己的眼光了。附带说一个，sogou的作者风格评价 实在是很好的点子很糟糕的技术，可能和样本太少也有关系，聚类结果差强人意。顺着这个，就牵涉到上下文相关广告和垃圾邮件处理，当然现在 英文领先的还是 Google, 中文也没有相关的比较出来。这是懂中文的一个非常重要的标准。

扩展二：能否进行高质量机器翻译
这一点是自然语言处理的本质，不敢做这个或者做不好这个都是不懂中文，或者在理解中文上有问题。这方面也是 Goolge 世界领先，（没办法，这个拼的就是语料库和计算能力，这个是我认为的”懂中文”的一个核心）

扩展三：拼音识别和相近词识别
有人说这个拼音识别 和近义词有什么难的？不就是输入法＋词典么。对的，说的很对，就是输入法加词典（当然也有复杂的技术我就不讲了）。可是如果这都做不好，谈什么懂中文呢 。

结语：判断”懂中文” 有客观标准，大约是 机器翻译 50%, 分词20％， 聚类＋搜索质量30％。
其他主观标准，我尊重你的判断，但是请不要用不懂中文这样的标题吓人，大家都是中国人，都懂你不懂什么叫不懂中文，都知道你不知道我知道你不知道我知道。附带说一句，从语义分析角度来说，新华字典懂汉字，不懂中文。