在参与这个讨论 http://www.iteye.com/topic/33971 后，这段时间对这个话题有了一些新的思考，写下来和大家分享分享。
重点探讨一下动静态编程语言的语义，兼带些DSL及通用语言，以及新手上手难易问题。
编程语言的语义，在论坛里讨论不多。在这里先分析一下几门主流静态语言，C，C++，Java，C#的语义。这些语言从编程风格角度讲，都称之为”imperative programming language”，（命令式的编程语言）。究其原因，这些语言都是对计算机的核心部件，CPU及内存，施发号令的。
1. int a = 4;
2. int b = 4 + a;
3. int c = 5.2345;
第一句，具体语义是，在内存里分配一块内存，大小为4 bytes，在这块内存里，写入4。第二句，具体语义是，在内存里分配一块内存，大小为4 bytes，从a中取值，和4进行加法运算，结果写入b指向的4 bytes内存。第三句就是个潜在的错误，等号右边是个8 bytes的double，把8 bytes的数据写到4 bytes的内存块里去，数据会损失的。
要把这些静态语言内存分配的经验照搬来理解动态语言，完全是搞错了方向。看看下面一段javascript代码：
1. var a = 5;
2. alert(a);
3. var a = "foobar";
4. alert(a);
这是一段完全合法可以正确运行的javascript程序，然而对于只编过静态语言而且对静态语言的语义很了解的人，却很难理解。变量a，明显不是指向根据类型分配出来一块大小固定的内存块。
如何理解这一段代码的语义？
Revised Report on the Algorithmic Language Scheme 一文里有这么一段：
引用
Scheme has latent as opposed to manifest types. Types are associated with values also (also call objects) rather than with variables. (Some authors refer to languages with latent types as weakly typed or dynamically typed languages. Other languages with latent types are APL, Snobol, and other dialects of Lisp. Languages with manifest types (sometimes referred to as strongly typed or statically typed language) include Algol 60, Pascal, and C.
Paul Graham在其“What Made Lisp Different”一文中这么说：
引用
A new concept of variables. In Lisp, all variables are effectively pointers. Values are what have types, not variables, and assigning or binding variables means copying pointers, not what they point to.
这两段合在一起，可以正确理解动态语言的语义。
静态，变量实际是分配的内存块，大小固定。
动态，变量实际是个指针，可指向内存任何一块。
(当然是运行的不同时期指向不同的内存块)
看看下面几句：
1. JavaScript: var a = 5;
2. ML: val a = 5;
3. Scheme: (define a 5)
这些语句应该理解为, (等号右边)表达式evaluate出来一个值，这个值绑定到变量a里面去。用来描述上述代码语义的正确的词是binding。
看看下面ML语言解释器对ML代码的解释：
1. Moscow ML version 2.01 (January 2004)
2. Enter `quit();' to quit.
3. - a;
4. ! Toplevel input:
5. ! a;
6. ! ^
7. ! Unbound value identifier: a
8. - val a = 5;
9. > val a = 5 : int
10. - a;
11. > val it = 5 : int
12. - val a = "foobar";
13. > val a = "foobar" : string
14. - a;
15. > val it = "foobar" : string
注意第七行的提示。
第十行，第十四行光打入a，也是个表达式，evaluate出来的值，绑定给省缺变量it。
看看下面Scheme语言解释器对Scheme代码的解释：
1. > a
2. ; Unbound variable: a
3.
4. > (define a 5)
5. ; Value: a
6.
7. > a
8. ; Value: 5
注意第二行的提示。
一定要分清动态语言的变量绑定和静态语言的变量赋值的区别。变量是一个数学上的概念，在静态语言中，叫变量其实不合适，还不如直接叫a memory box，更能清楚地说明其本质。
对于静态语言，弱类型是致命伤，因为在声明变量的时候，内存块已经分配好了，往这个内存块里写一块内存块存储不下的数据，带来的伤害是致命的。对于动态语言，强弱类型未必重要。
在C/C++/Java/C#里面，内存是可以分配到Stack里面，也可以分配到Heap里面, 程序员一定要搞清楚区别, 像在C里：
1. int a = 5;
2. int b[] = { 1, 2, 3, 4}
3. int* ptr = (int*)malloc(10*sizeof(int));
a 和 b 所分配的内存都在stack里，c 指向heap里的一块，退出前不把c 给free掉，就会遗漏内存。给function传值的时候，更要小心，传a是把5这个值给传过去，传b是传b这个array第一个元素的地址。
到了C++，更加繁琐，因为C++的 Object是可以分配在stack上的，随便写几句代码，都会用到assignment operator = , address-of operator &, copy constructor.
1. const ClassFoo e1; // default constructor, destructor later
2. ClassFoo e2(e1); // copy constructor
3. e2 = e1; // assignment operator
4. ClassFoo *pe2 = &e2; // address-of operator (non-const)
5. const ClassFoo *pe1 = &e1; // address-of operator (const)
C++编译器自动生成这些函数，有时不符合需要就要自己手写。
Java里面所有的object allocation, 都是分配在Heap里的，光这一点，就大大减轻了编程的繁琐度。从Java转向C++的朋友，一定要记住这一点。C++的 Object是可以分配在stack上的。
Java里面的primitive变量是分配在Stack上的，其实如果废除这八个primitive types，全部用Object reference，动静态语言的差别已经不那么大了。Type inference在C# 3里面，已经开始实现了：
1. var str = "Hello world!";
2. var num = 42;
3. var v = new TypeWithLongName<AndWithTypeParameter>();
欧美计算机专业的第一门语言，一般是ML或Scheme。这些语言，做到了程序员不用思考内存是分配在stack上还是heap上，内存回收由GC管，因而可以集中精力，学习算法，递归等等。
用编程来解决问题，需要三方面的技能：1. 对编程语言，语义及运行环境的掌握，2. 对解决问题的算法的掌握，3. 拥有写出结构清晰，简洁易懂的代码的能力。
第一点和第二点经常交汇在一起，因为语言，经常是为了解决某个领域的问题而设计的，解决算法，递归之类的问题，用functional programming language，操作系统，应该用C，web领域之PHP，科学计算之Matlab，试验仪器控制之labview，关系数据库之SQL，莫不如此。
那么什么算是通用语言，什么算是DSL？通用不通用是相对的。C是一门通用语言，但也可以说是操作系统的DSL。从某种角度来说，能够全面控制计算机的，才叫通用语言，那么只有汇编才符合这个条件，C和C++勉强算得上。
新手上路，该学什么？应该从某个领域学起，学习解决那个领域问题需要的方法，而且学习那个领域的DSL。这样成效出的最快，而且不受干扰。
现在学校里教学静态语言占主流，有历史原因。以前计算机不够快，用C编程是唯一的选择。现在对运行效率要求很高的领域，还得用C，C++。但是在很多领域，这已经不是个问题了。由于历史的惯性，静态语言还在继续教。学校老师学新知识的动力，可不大。这些老师教出的学生，只会静态语言，那么公司为了保证人手充足，也会倾向静态语言。这种状况，慢慢会打破。