這是一篇發表在《程式設計師》雜誌8月刊的文章，是根據我對Anders Hejlsberg的演講內容的翻譯的縮寫。原本的完整演講內容有數萬字，為了在雜誌上發表因此簡化成了五千字，因此如果您對完整內容感興趣，不妨根據文末連結來訪問完整內容，其中也包含大量分解的幻燈片以及程式碼。

概述

程式設計離不開程式語言，但是程式語言在國內的大環境中似乎一直是個二等公民。國內的計算機教育和工程培訓，似乎一直在宣傳“語言不重要，重要的是思想”，“語言一通百通”等觀點，甚至在許多人眼中“語言的討論”完全是不入流的，但其實“程式語言”與“工具”、“框架”或是“開發方法”等事物一樣，都對生產力有著重要的影響。事實上，語言的發展歷史比其他方面更為悠久，並且在過去十幾年，甚至最近幾年中都依然在不斷的碰撞，演變。期間一些新的語言誕生了，而另一些在當時看來陽春白雪的語言和程式設計正規化也重新獲得了人們的重視。

Anders Hejlsberg是微軟的Technical Fellow，擔任C#程式語言的首席架構師，也參與了.NET Framework，以及VB.NET和F#等語言的設計與開發。幾個月前，Anders在比利時的TechDays 2010及荷蘭DevDays 2010分別進行了一場演講，闡述了他眼中對於程式語言的發展趨勢及未來方向，本文便對他的觀點進行了總結。

大約25到30年前，Anders開發了著名的Turbo Pascal，這是一套集語言、編譯器及開發工具於一體的產品，這也是Anders進入程式語言這一領域的起點。Anders談到，如今的計算機和當年他開發的Turbo Pascal所用的

Z-80已經不可同日而語。從那時算起，如今的機器已經有大約10萬倍的外部儲存容量，1萬倍的記憶體大小，CPU速度也有大約1000倍的提高。但是，如果我們比較如今的Java程式碼及當年Pascal程式碼，會發現它們的差別其實並不大。Anders認為程式語言的發展非常緩慢，期間當然出現了一些東西，例如面向物件等等，但是遠沒有好上1000倍。事實上，近幾十年來的努力主要體現在框架及工具等方面（如下圖）。例如.NET Framework裡有超過一萬個類及十萬個方法，與Turbo Pascal相比的確有了超過1000倍的增長。同樣類似，現在的IDE包含了無數強大的功能，例如語法提示，重構，偵錯程式等等。與此相比，程式語言的改進的確很不明顯。

在過去5、60年的程式設計歷史中，程式語言的抽象級別不斷提高，人們都在努力讓程式語言更有表現力，這樣我們可以用更少的程式碼完成更多的工作。我們一開始使用匯編，然後使用面向過程的語言（如Pascal和C），然後是面嚮物件語言（如C++），隨後便進入了託管時代，語言運行於受託管的執行環境上（如C#，Java），它們的主要特性有自動的垃圾收集，型別安全等等。Anders認為這樣的趨勢還會繼續保持下去，我們還會看到抽象級別越來越高的語言，而語言的設計者則必須理解並預測下一個抽象級別是什麼樣子的。另一方面，如.NET，Java等框架的重要性提高了許多，程式語言往往都傾向於構建於現有的工具上，而不會從頭寫起。現在出現的程式語言，例如F#，以及Java領域的Scala，Clojure等等，它們都是基於現有框架構建的，每次從頭開始的代價實在太高。

在Anders眼中，如今影響力較大的趨勢主要有三種（如下圖），它們分別是“宣告式的程式設計風格”（包括“領域特定語言”及“函數語言程式設計”）、過去的五年非常火熱的“動態語言”（其最重要的方面便是“超程式設計”能力）以及多核環境下的“併發程式設計。此外隨著語言的發展，原本常用的“面向物件”語言，“動態語言”或是“函式式”等邊界也變得越來越模糊，例如各種主要的程式語言都受到函式式語言的影響。因此，“多正規化”程式設計語言也是一個愈發明顯的趨勢。

宣告式程式設計與DSL

目前常見的程式語言大都是命令式（Imperative）的，例如C#，Java或是C++等等。這些語言的特徵在於，程式碼裡不僅表現了“做什麼（What）”，而更多表現出“如何（How）完成工作”這樣的實現細節，例如for迴圈，i += 1等等，甚至這部分細節會掩蓋了我們的“最終目標”。在Anders看來，指令式程式設計通常會讓程式碼變得十分冗餘，更重要的是由於它提供了過於具體的指令，這樣執行程式碼的基礎設施（如CLR或JVM）沒有太多發揮空間，只能老老實實地根據指令一步步的向目標前進。例如，並行執行程式會變得十分困難，因為像“執行目的”這樣更高層次的資訊已經丟失了。因此，程式語言的趨勢之一，便是能讓程式碼包含更多的“What”，而不是“How”，這樣執行環境便可以更加聰明地去適應當前的執行要求。

關於宣告式的程式設計風格，Anders主要提出了兩個方面，第一個方面是DSL（Domain Specific Language，領域特定語言）。DSL不是什麼新鮮的玩意兒，我們平時經常接觸的SQL，CSS，正則表示式等等都屬於DSL。有的DSL可能更加專注於一個方面，例如Mathematica，LOGO等等。這些語言的目標都是特定的領域，與之相對的則是GPPL（General Purpose Programming Language，通用目的程式語言）。Martin Fowler將DSL分為外部DSL及內部DSL兩種。外部DSL有自己的特定語法、解析器和詞法分析器等等，它們往往是一種小型的程式語言，甚至不會像GPPL那樣需要原始檔。與之相對的則是內部DSL。內部DSL其實更像是種別稱，它代表一類特別API及使用模式。

XSLT，SQL等等都可以算作是外部DSL。外部DSL一般會直接針對特定的領域設計，而不考慮其他方面。James Gosling曾經說過：每個配置檔案最終都會變成一門程式語言。一開始您可能只會用它表示一點點東西，慢慢地您便會想要一些規則，而這些規則則變成了表示式，後來您可能還會定義變數，進行條件判斷等等，而最終它就變成了一種奇怪的程式語言，這樣的情況屢見不鮮。現在有一些公司也在關注DSL的開發。例如以前在微軟工作的Charles Simonyi提出了Intentional Programming的概念，還有JetBrains公司提供的一個叫做MPS（Meta Programming System）的產品。最近微軟也提出了自己的Oslo專案，而在Eclipse世界裡也有Xtext，所以其實如今在這方面也有不少人在嘗試。由於外部DSL的獨立性，在某些情況下也會出現特定的工具，輔助領域專家或是開發人員本身編寫DSL程式碼。還有一些DSL會以XML方言的形式提出，利用XML方言的好處在於有不少現成的工具可用，這樣可以更快地定義自己的語法。

而內部DSL，正像之前提到的那樣，它往往只是代表了一系列特別的API及使用模式，例如LINQ查詢語句及Ruby on Rails中的Active Record宣告程式碼等等。內部DSL可以使用一系列API來“偽裝”成一種DSL，它往往會利用一些“流暢化”的技巧，例如像jQuery那樣把一些方法通過“點”連線起來，而另一些也會利用超程式設計的方式。內部DSL還有一些優勢，例如可以訪問語言中的程式碼或變數，以及利用程式碼補全，重構等母語言的所有特性。

DSL的可讀性往往很高。例如，要篩選出單價大於20的產品，並對所屬種類進行分組，並降序地列出每組的分類名稱及產品數量。如果是用命令式的程式設計方式，則可能是這樣的：

Dictionary<string, Grouping> groups = new Dictionary<string, Grouping>();
foreach (Product p in products)
{
    if (p.UnitPrice >= 20)
    {
        if (!groups.ContainsKey(p.CategoryName))
        {
            Grouping r = new Grouping();
            r.CategoryName = p.CategoryName;
            r.ProductCount = 0;
            groups[p.CategoryName] = r;
        }
        groups[p.CategoryName].ProductCount++;
    }
}

List<Grouping> result = new List<Grouping>(groups.Values);
result.Sort(delegate(Grouping x, Grouping y)
{
    return
        x.ProductCount > y.ProductCount ? -1 :
        x.ProductCount < y.ProductCount ? 1 :
        0;
});

顯然這些程式碼編寫起來需要一點時間，且很難直接看出它的真實目的，換言之“What”幾乎完全被“How”所代替了。這樣，一個新的程式設計師必須花費一定時間才能理解這段程式碼的目的。但如果使用LINQ，程式碼便可以改寫成：

var result = products
    .Where(p => p.UnitPrice >= 20)
    .GroupBy(p => p.CategoryName)
    .OrderByDescending(g => g.Count())
    .Select(g => new { CategoryName = g.Key, ProductCount = g.Count() });

這段程式碼更加關注的是“What”而不是“How”，它不會明確地給出過濾的“操作方式”，也沒有涉及到建立字典這樣的細節。這段程式碼還可以利用C# 3.0中內建的DSL，即LINQ查詢語句來改寫：

var result =
    from p in products
    where p.UnitPrice >= 20
    group p by p.CategoryName into g
    orderby g.Count() descending
    select new { CategoryName = g.Key, ProductCount = g.Count() };

編譯器會簡單地將LINQ差距語句轉化為前一種形式。這段程式碼只是表現出最終的目的，而不是明確指定做事的方式，這樣便可以很容易地並行執行這段程式碼，如使用PINQ則幾乎不需要做出任何修改。

函數語言程式設計

Anders提出的另一個重要的宣告式程式設計方式便是函數語言程式設計。函數語言程式設計歷史悠久，它幾乎和程式語言本身同時誕生，如當年的LISP便是個函數語言程式設計語言。除了LISP以外還有其他許多函數語言程式設計語言，如APL、Haskell、ML等等。關於函數語言程式設計在學術界已經有過許多研究了，大約在5到10年前許多人開始吸收和整理這些研究內容，想要把它們融入更為通用的程式語言。現在的程式語言，如C#、Python、Ruby、Scala等等，它們都受到了函數語言程式設計語言的影響。

使用指令式程式設計語言寫程式時，我們經常會編寫如x = x + 1這樣的語句，此時我們大量依賴的是可變狀態，或者說是“變數”，它們的值可以隨程式執行而改變。可變狀態非常強大，但隨之而來的便是被稱為“副作用”的問題，例如一個無需引數的void方法，它會根據呼叫次數或是在哪個執行緒上進行呼叫對程式產生影響，它會改變程式內部的狀態，從而影響之後的執行效果。而在函數語言程式設計中則不會出現這個情況，因為所有的狀態都是不可變的。事實上對函數語言程式設計的討論更像是數學、公式，而不是程式語句，如x = x + 1對於數學家來說，似乎只是個永不為真的表示式而已。

函數語言程式設計十分容易並行，因為它在執行時不會修改任何狀態，因此無論多少執行緒在執行時都可以觀察到正確的結果。假如兩個函式完全無關，那麼它們是並行還是順序地執行便沒有什麼區別了。當然，現實中的程式一定是有副作用的，例如向螢幕輸出內容，向Socket傳輸資料等等，因此真實世界中的函數語言程式設計往往都會考慮如何將有副作用的程式碼分離出來。函數語言程式設計預設是不可變的，開發人員必須做些額外的事情才能使用可變狀態或是危險的副作用，與之相反，如C#或Java必須使用readonly或是final來做到這一點。此時，使用函數語言程式設計語言時的思維觀念便會有所不同了。

F#是微軟隨VS 2010推出的一門函數語言程式設計語言，它基於OCaml的核心部分，因此是一門強型別程式語言，並支援一些如模式匹配，型別推斷等現代函數語言程式設計語言的特性。在此之上，F#又增加了非同步工作流，度量單位等較為前沿的語言功能。在F#中如果要計算一個列表所有元素之和，也可以使用命令式的風格來編寫程式碼：

let sumSquaresI l = 
    let mutable acc = 0
    for x in l do
        acc <- acc + sqr x
    acc

只不過，F#中的一切預設都是不可變的，開發人員需要使用mutable關鍵字來宣告一個可變的狀態。事實上，在F#中更典型做法是：

let rec sumSquaresF l = 
    match l with
    | [] -> 0
    | head :: tail -> sqr head + sumSquaresF tail

在數學裡我們經常使用遞迴，把一個公式分解成幾個變化的形式，以此進行遞迴的定義。純函式式的程式碼其“數學性”較強，如果您分析上面這段程式碼，會發現它幾乎就是標準的數學定義。在程式設計時我們也使用遞迴的做法，編譯器會設法幫我們轉化成尾呼叫或是迴圈語句。

動態語言與超程式設計

動態語言不會嚴格區分“編譯時”和“執行時”。對於一些靜態程式語言（如C#），往往是先進行編譯，此時可能會得到一些編譯期錯誤，而對於動態語言來說這兩個階段便混合在一起了。常見的動態語言有JavaScript，Python，Ruby，LISP等等。動態語言和靜態語言各有一些優勢，這也是兩個陣營爭論多年的內容。不過Anders認為它們各自都有十分重要的優點，而未來不屬於其中任何一方。他表示，從程式語言發展過程中可以觀察到兩種特點正在合併的趨勢，未來應該屬於兩者的雜交產物。

許多人認定動態語言執行起來很慢，也沒有型別安全等等。例如有這樣一段程式碼：

var a = 0, n = 10;
for (var i = 0; i < n; i++) {
    a += i;
}

這段程式碼在C#和JavaScript中都是合法的，但是它們的處理方式大相徑庭。在C#中，編譯器可以推斷出a和n都是32位整數，則for迴圈和相加操作都只是簡單的CPU指令，自然效率很高。但是對於JavaScript等動態型別語言來說，var只代表了“一個值”，它可以是任意型別，因此這裡其實還會包含一個“型別標記”，表明它在執行時是什麼型別的物件。所以兩者的區別之一便是，表示同樣的值在動態語言中會有一些額外的開銷，在如今的CPU中，“空間”也意味著“速度”，所以較大的值便需要較長時間進行處理，這裡便損失了一部分效率。此外JavaScript在計算a加i時，那麼必須先檢視兩個變數中的型別標記，根據型別選擇出合適的相加操作，然後載入兩個值，最後再進行加法操作，一旦越界了還要利用double。很明顯在這裡也會帶來許多開銷。一般來說，動態語言是使用直譯器來執行的，因此還有一些直譯器需要的二進位制碼，把這些效能損失全部加起來以後，便會發現執行程式碼時需要10倍到100倍的效能開銷。

不過近幾年出現的一些動態虛擬機器或引擎將此類情況改善了許多。如今大部分的JavaScript引擎使用了JIT編譯器，於是便省下了直譯器的開銷，這樣效能損失便會減小至3到10倍。而在過去的兩三年間，JIT編譯器也變得越來越高效，瀏覽器中新一代的適應性JIT編譯器，如TraceMonkey，V8，還有微軟在IE 9中使用的Chakra引擎。這種適應性的JIT編譯器使用了一部分有趣的技術，如Inline Caching、Type Specialization、Hidden Classes、Tracing等等，它們可以將開銷降低至2到3倍的範圍內，這種效率的提升可謂十分神奇。在Anders看來，JavaScript引擎可能已經接近了效能優化的極限，我們在效率上可以提升的空間已經不多。不過他同樣認為，如今JavaScript語言的效能已經足夠快了，完全有能力作為Web客戶端的統治性語言。

動態語言的關鍵之一便是“超程式設計”，“超程式設計”實際上是“程式碼生成”的一種別稱，在日常應用中開發人員其實經常依賴這種做法了。在某些場景下使用動態語言會比靜態語言更加自然一些。例如在C#或Java裡使用ORM時，一種傳統做法是讓程式碼生成器去觀察資料庫，並生成一大堆程式碼，然後再編譯。而動態語言並沒有編譯期和執行期的區別，例如在Ruby on Rails中使用ActiveRecord便無須定義各式欄位。

Anders談到，他和他的團隊也在努力改進靜態語言的超程式設計能力，如他們正在實現的“編譯器即服務（Compiler as a Service）”。傳統的編譯器是一個黑盒，一端輸入程式碼，而另一端便會生成.NET程式集等資料，開發人員很難參與或理解它的工作。但是在很多時候，開發人員並不一定需要編譯器來生成程式集，他們需要的是一些樹狀的表現形式，然後對它進行識別和重寫。因此，開發人員可能會越來越需要一些開放編譯器功能的API。這麼做可以讓靜態型別語言獲得許多有用的功能，包括超程式設計以及可操作的完整物件模型等等。

併發

Anders看來，多核革命的一個有趣之處在於，它會要求併發的思維方式有所改變。傳統的併發思維，是在單個CPU上執行多個邏輯任務，使用舊有的分時方式或是時間片模型來執行多個任務。但是如今的併發場景則正好相反，是要將一個邏輯上的任務放在多個CPU上執行。這改變了我們編寫程式的方式，這意味著對於語言或是API來說，我們需要有辦法來分解任務，把它拆分成多個小任務後獨立的執行，而傳統的程式語言中並不關注這點。

使用目前的併發API來完成工作並不容易，比如Thread，ThreadPool，Monitor等等，開發人員很難走的太遠。不過在.NET 4.0中提供了一套強大的框架，即.NET並行擴充套件（Parallel Extensions），這是一種現代的併發模型，將邏輯上的任務併發與實際使用的的物理模型分離開來。以前的API都是直接處理執行緒等基礎元素，不過利用.NET並行擴充套件中的任務並行庫（Task Parallel Library），並行LINQ（Parallel LINQ）以及協調資料結構（Coordination Data Structures）讓開發人員可以直接關注邏輯上的任務，而不必關心它們是如何執行的，或是使用了多少個執行緒和CPU等等。利用LINQ這樣的DSL也有助於寫出並行的程式碼，如果使用普通的for迴圈配合執行緒池來實現並行，則開發人員很容易在各種API裡失去方向。

不過事實上，編寫並行的程式碼依然很困難，尤其是要識別出可以並行的地方。Anders認為很多時候還是需要程式語言來關注這方面的事情（如下圖）。比如“隔離性（Isolation）”，即編譯器如何發現這段程式碼是獨立的，便可以將其安全地併發執行。某段程式碼建立了一個物件，在分享給其他人之前，我們對它的改變是安全的，但是一旦將其共享出去以後便完全不同了。因此理想中的型別系統應該可以跟蹤到這樣的共享，如Linear Types——這在學術界也有一些研究。程式語言也可以在函式的純潔性（Purity）方面下功夫，如關注某個函式是否有副作用，有些時候編譯器可以做這方面的檢查，它可以禁止某些操作，以此保證我們寫出無副作用的純函式。另外便是不可變性（Immutability），目前的語言，如C#或VB，我們需要額外的工作才能寫出不可變的程式碼。Anders認為合適的做法應該是在語言層面上更好的支援不可變性。這些都是在併發方面需要考慮的問題。

Anders還提到了他在思考併發語言特性時所遵循的原則：一個語言特性不應該針對某個特定的併發模型，而應該是一種通用的，可用於各種不同的併發場景的特性，就像隔離性、純潔性及不可變性那樣。語言擁有這樣的特性之後，就可以用於構建各種不同的API，各種併發方式都可以利用到核心的語言特性。

總結

Anders認為，對於程式語言來說，現在出現了許多有趣的東西，也是個令人激動的時刻。在過去，大約是1995到2005年，的確可以說是一個程式語言的黃金時期。當Java出現的時候，程式語言的門檻變得平坦了，一切都是Java，似乎其他程式語言都完蛋了，程式設計者也沒什麼可做的。不過大家又逐漸發現，其實這遠沒有結束。現在回顧起來，會發現這段時間又出現了許多有趣的程式語言，這其實也代表了我們在程式設計領域上的進步。

完整內容