永遠不要（把自己遇到的問題）歸因于（他人的）惡意，這恰恰說明了（你自己的）無能。—— 拿破侖

為了造福大眾，在 Java 編程領域創造就業機會，兄弟我在此傳授大師們的秘籍。這些大師寫的代碼極其難以維護，后繼者就是想對它做最簡單的修改都需要花上數年時間。而且，如果你能對照秘籍潛心修煉，你甚至可以給自己弄個鐵飯碗，因為除了你之外，沒人能維護你寫的代碼。再而且，如果你能練就秘籍中的全部招式，那么連你自己都無法維護你的代碼了！

你不想練功過度走火入魔吧。那就不要讓你的代碼一眼看去就完全無法維護，只要它實質上是那樣就行了。否則，你的代碼就有被重寫或重構的風險！

0、總則

Quidquid latine dictum sit, altum sonatur.

(隨便用拉丁文寫點啥，都會顯得高大上。)

想挫敗維護代碼的程序員，你必須先明白他的思維方式。他接手了你的龐大程序，沒有時間把它全部讀一遍，更別說理解它了。他無非是想快速找到修改代碼的位置、改代碼、編譯，然后就能交差，并希望他的修改不會出現意外的副作用。

他查看你的代碼不過是管中窺豹，一次只能看到一小段而已。你要確保他永遠看不到全貌。要盡量讓他難以找到他想找的代碼。但更重要的是，要讓他不能有把握忽略任何東西。

程序員都被編程慣例洗腦了，還為此自鳴得意。每一次你處心積慮地違背編程慣例，都會迫使他必須用放大鏡去仔細閱讀你的每一行代碼。

你可能會覺得每個語言特性都可以用來讓代碼難以維護，其實不然。你必須精心地誤用它們才行。

1、命名

“當我使用一個單詞的時候” Humpty Dumpty 曾經用一種輕蔑的口氣說, “它就是我想表達的意思，不多也不少。“– Lewis Carroll —《愛麗絲魔鏡之旅》，第 6 章

編寫無法維護代碼的技巧的重中之重是變量和方法命名的藝術。如何命名是和編譯器無關的。這就讓你有巨大的自由度去利用它們迷惑維護代碼的程序員。

妙用寶寶起名大全

買本寶寶起名大全，你就永遠不缺變量名了。比如 Fred 就是個好名字，而且鍵盤輸入它也省事。如果你就想找一些容易輸入的變量名，可以試試 adsf 或者 aoeu之類。

單字母變量名

如果你給變量起名為 a,b,c，用簡單的文本編輯器就沒法搜索它們的引用。而且，沒人能猜到它們的含義。

創造性的拼寫錯誤

如果你必須使用描述性的變量和函數名，那就把它們都拼錯。還可以把某些函數和變量名拼錯，再把其他的拼對（例如 SetPintleOpening 和 SetPintalClosing)），我們就能有效地將 grep或 IDE 搜索技術玩弄于股掌之上。這招超級管用。還可以混淆不同語言（比如 colour — 英國英語，和 color — 美國英語)。

抽象

在命名函數和變量的時候，充分利用抽象單詞，例如 it, everything, data, handle, stuff, do, routine, perform 和數字，像這樣命名的好例子有 routineX48, PerformDataFunction, DoIt, HandleStuff 還有 do_args_method。

首字母大寫的縮寫

用首字母大寫縮寫（比如GNU 代表 GNU’s Not Unix) 使代碼簡潔難懂。真正的漢子(無論男女)從來不說明這種縮寫的含義，他們生下來就懂。

辭典大輪換

為了打破沉悶的編程氣氛，你可以用一本辭典來查找盡量多的同義詞。例如 display, show, present。在注釋里含糊其辭地暗示這些命名之間有細微的差別，其實根本沒有。不過，如果有兩個命名相似的函數真的有重大差別，那倒是一定要確保它們用相同的單詞來命名(例如，對于 “寫入文件”, “在紙上書寫” 和 “屏幕顯示” 都用 print 來命名)。在任何情況下都不要屈服于編寫明確的項目詞匯表這種無理要求。你可以辯解說，這種要求是一種不專業的行為，它違反了結構化設計的信息隱藏原則。

首字母大寫

隨機地把單詞中間某個音節的首字母大寫。例如 ComputeReSult()。

重用命名

在語言規則允許的地方，盡量把類、構造器、方法、成員變量、參數和局部變量都命名成一樣。更高級的技巧是在{}塊中重用局部變量。這樣做的目的是迫使維護代碼的程序員認真檢查每個示例的作用域。特別是在Java代碼中，可以把普通方法偽裝成構造器。

使用非英語字母

在命名中偷偷使用不易察覺的非英語字母，例如

typedef struct { int i; } ínt;

看上去沒啥不對是吧？嘿嘿嘿…這里的第二個 ínt 的 í 實際上是東北歐字母，并不是英語中的 i 。在簡單的文本編輯器里，想看出這一點點區別幾乎是不可能的。

巧妙利用編譯器對于命名長度的限制

如果編譯器只區分命名的前幾位，比如前8位，那么就把后面的字母寫得不一樣。比如，其實是同一個變量，有時候寫成 var_unit_update() ，有時候又寫成 var_unit_setup()，看起來是兩個不同的函數調用。而在編譯的時候，它們其實是同一個變量 var_unit。

下劃線，真正的朋友

可以拿 _ 和 __ 作為標示符。

混合多語言

隨機地混用兩種語言（人類語言或計算機語言都行）。如果老板要求使用他指定的語言，你就告訴他你用自己的語言更有利于組織你的思路，萬一這招不管用，就去控訴這是語言歧視，并威脅起訴老板要求巨額精神損失賠償。

擴展 ASCII 字符

擴展 ASCII 字符用于變量命名是完全合法的，包括 ?, D, 和 ? 等。在簡單的文本編輯器里，除了拷貝/粘貼，基本上沒法輸入。

其他語言的命名

使用外語字典作為變量名的來源。例如，可以用德語單詞 punkt 代替 point。除非維護代碼的程序員也像你一樣熟練掌握了德語. 不然他就只能盡情地在代碼中享受異域風情了。

數學命名

用數學操作符的單詞來命名變量。例如：

openParen = (slash + asterix) / equals;

(左圓括號 = (斜杠 + 星號)/等號;)

令人眩暈的命名

用帶有完全不相關的感情色彩的單詞來命名變量。例如：

marypoppins = (superman + starship) / god;

(歡樂滿人間 = (超人 + 星河戰隊)/上帝;)

這一招可以讓閱讀代碼的人陷入迷惑之中，因為他們在試圖想清楚這些命名的邏輯時，會不自覺地聯系到不同的感情場景里而無法自拔。

何時使用 i

永遠不要把 i 用作最內層的循環變量。用什么命名都行，就是別用 i。把 i 用在其他地方就隨便了，用作非整數變量尤其好。

慣例 — 明修棧道，暗度陳倉

忽視 Java 編碼慣例，Sun 自己就是這樣做的。幸運的是，你違反了它編譯器也不會打小報告。這一招的目的是搞出一些在某些特殊情況下有細微差別的名字來。如果你被強迫遵循駝峰法命名，你還是可以在某些模棱兩可的情況下顛覆它。例如，inputFilename 和 inputfileName 兩個命名都可以合法使用。在此基礎上自己發明一套復雜到變態的命名慣例，然后就可以痛扁其他人，說他們違反了慣例。

小寫的 l 看上去很像數字 1

用小寫字母 l 標識 long 常數。例如 10l 更容易被誤認為是 101 而不是 10L 。禁用所有能讓人準確區分uvw wW gq9 2z 5s il17|!j oO08 `’” ;,. m nn rn {[()]}的字體。要做個有創造力的人。

把全局命名重用為私有

在 A 模塊里聲明一個全局數組，然后在 B 模塊的頭文件里在聲明一個同名的私有數組，這樣看起來你在 B 模塊里引用的是那個全局數組，其實卻不是。不要在注釋里提到這個重復的情況。

誤導性的命名

讓每個方法都和它的名字蘊含的功能有一些差異。例如，一個叫 isValid(x) 的方法在判斷完參數 x 的合法性之后，還順帶著把它轉換成二進制并保存到數據庫里。

2、偽裝

當一個 bug 需要越長的時間才會暴露，它就越難被發現。- Roedy Green

編寫無法維護代碼的另一大秘訣就是偽裝的藝術，即隱藏它或者讓它看起來像其他東西。很多招式有賴于這樣一個事實：編譯器比肉眼或文本編輯器更有分辨能力。下面是一些偽裝的最佳招式。

把代碼偽裝成注釋，反之亦然

下面包括了一些被注釋掉的代碼，但是一眼看去卻像是正常代碼。

for(j=0; j

{

total += array[j+0 ];

total += array[j+1 ];

total += array[j+2 ];/* Main body of

total += array[j+3];* loop is unrolled

total += array[j+4];* for greater speed.

total += array[j+5];*/

total += array[j+6 ];

total += array[j+7 ];

}

如果不是用橘色標出來，你能注意到這三行代碼被注釋掉了么？

用連接符隱藏變量

對于下面的定義

#define local_var xy_z

可以把 “xy_z” 打散到兩行里：

#define local_var xy

_z // local_var OK

這樣全局搜索 xy_z 的操作在這個文件里就一無所獲了。對于 C 預處理器來說，第一行最后的 “” 表示繼續拼接下一行的內容。

3、文檔

任何傻瓜都能說真話，而要把謊編圓則需要相當的智慧。—— Samuel Butler (1835 – 1902)

不正確的文檔往往比沒有文檔還糟糕。—— Bertrand Meyer

既然計算機是忽略注釋和文檔的，你就可以在里邊堂而皇之地編織彌天大謊，讓可憐的維護代碼的程序員徹底迷失。

在注釋中撒謊

實際上你不需要主動地撒謊，只要沒有及時保持注釋和代碼更新的一致性就可以了。

只記錄顯而易見的東西

往代碼里摻進去類似于

/* 給 i 加 1 */

這樣的注釋，但是永遠不要記錄包或者方法的整體設計這樣的干貨。

記錄 How 而不是 Why

只解釋一個程序功能的細節，而不是它要完成的任務是什么。這樣的話，如果出現了一個bug，修復者就搞不清這里的代碼應有的功能。

該寫的別寫

比如你在開發一套航班預定系統，那就要精心設計，讓它在增加另一個航空公司的時候至少有 25 處代碼需要修改。永遠不要在文檔里說明要修改的位置。后來的開發人員要想修改你的代碼？門都沒有，除非他們能把每一行代碼都讀懂。

計量單位

永遠不要在文檔中說明任何變量、輸入、輸出或參數的計量單位，如英尺、米、加侖等。計量單位對數豆子不是太重要，但在工程領域就相當重要了。同理，永遠不要說明任何轉換常量的計量單位，或者是它的取值如何獲得。要想讓代碼更亂的話，你還可以在注釋里寫上錯誤的計量單位，這是赤裸裸的欺騙，但是非常有效。如果你想做一個惡貫滿盈的人，不妨自己發明一套計量單位，用自己或某個小人物的名字命名這套計量單位，但不要給出定義。萬一有人挑刺兒，你就告訴他們，你這么做是為了把浮點數運算湊成整數運算而進行的轉換。

坑

永遠不要記錄代碼中的坑。如果你懷疑某個類里可能有bug，天知地知你知就好。如果你想到了重構或重寫代碼的思路，看在老天爺的份上，千萬別寫出來。切記電影《小鹿斑比》里那句臺詞 “如果你不能說好聽的話，那就什么也不要說。”。萬一這段代碼的原作者看到你的注釋怎么辦？萬一老板看到了怎么辦？萬一客戶看到了怎么辦？搞不好最后你自己被解雇了。一句”這里需要修改“的匿名注釋就好多了，尤其是當看不清這句注釋指的是哪里需要修改的情況下。切記“難得糊涂”四個字，這樣大家都不會感覺受到了批評。

說明變量

永遠不要對變量聲明加注釋。有關變量使用的方式、邊界值、合法值、小數點后的位數、計量單位、顯示格式、數據錄入規則等等，后繼者完全可以自己從程序代碼中去理解和整理嘛。如果老板強迫你寫注釋，就把方法體代碼混進去，但絕對不要對變量聲明寫注釋，即使是臨時變量！

在注釋里挑撥離間

為了阻撓任何雇傭外部維護承包商的傾向，可以在代碼中散布針對其他同行軟件公司的攻擊和抹黑，特別是可能接替你工作的其中任何一家。例如：

/* 優化后的內層循環

這套技巧對于SSI軟件服務公司的那幫蠢材來說太高深了，他們只會

用 里的笨例程，消耗50倍的內存和處理時間。

*/

class clever_SSInc

{

.. .

}

可能的話，除了注釋之外，這些攻擊抹黑的內容也要摻到代碼里的重要語義部分，這樣如果管理層想清理掉這些攻擊性的言論然后發給外部承包商去維護，就會破壞代碼結構。

4、程序設計

編寫無法維護代碼的基本規則就是：在盡可能多的地方，以盡可能多的方式表述每一個事實。- Roedy Green

編寫可維護代碼的關鍵因素是只在一個地方表述應用里的一個事實。如果你的想法變了，你也只在一個地方修改，這樣就能保證整個程序正常工作。所以，編寫無法維護代碼的關鍵因素就是反復地表述同一個事實，在盡可能多的地方，以盡可能多的方式進行。令人高興的是，像Java這樣的語言讓編寫這種無法維護代碼變得非常容易。例如，改變一個被引用很多的變量的類型幾乎是不可能的，因為所有造型和轉換功能都會出錯，而且關聯的臨時變量的類型也不合適了。而且，如果變量值要在屏幕上顯示，那么所有相關的顯示和數據錄入代碼都必須一一找到并手工進行修改。類似的還有很多，比如由C和Java組成的Algol語言系列，Abundance甚至Smalltalk對于數組等結構的處理，都是大有可為的。

Java 造型

Java 的造型機制是上帝的禮物。你可以問心無愧地使用它，因為 Java 語言本身就需要它。每次你從一個 Collection 里獲取一個對象，你都必須把它造型為原始類型。這樣這個變量的類型就必須在無數地方表述。如果后來類型變了，所有的造型都要修改才能匹配。如果倒霉的維護代碼的程序員沒有找全（或者修改太多），編譯器能不能檢測到也不好說。類似的，如果變量類型從short 變成 int，所有匹配的造型也都要從(short) 改成 (int)。

利用 Java 的冗余

Java 要求你給每個變量的類型寫兩次表述。Java 程序員已經習慣了這種冗余，他們不會注意到你的兩次表述有細微的差別，例如

Bubblegum b = new Bubblegom();

不幸的是 ++ 操作符的盛行讓下面這種偽冗余代碼得手的難度變大了：

swimmer = swimner + 1;

永遠不做校驗

永遠不要對輸入數據做任何的正確性或差異性檢查。這樣能表現你對公司設備的絕對信任，以及你是一位信任所有項目伙伴和系統管理員的團隊合作者。總是返回合理的值，即使數據輸入有問題或者錯誤。

有禮貌，無斷言

避免使用 assert() 機制，因為它可能把三天的debug盛宴變成10分鐘的快餐。

避免封裝

為了提高效率，不要使用封裝。方法的調用者需要所有能得到的外部信息，以便了解方法的內部是如何工作的。

復制粘貼修改

以效率的名義，使用 復制+粘貼+修改。這樣比寫成小型可復用模塊效率高得多。在用代碼行數衡量你的進度的小作坊里，這招尤其管用。

使用靜態數組

如果一個庫里的模塊需要一個數組來存放圖片，就定義一個靜態數組。沒人會有比 512 x 512 更大的圖片，所以固定大小的數組就可以了。為了最佳精度，就把它定義成 double 類型的數組。

傻瓜接口

編寫一個名為 “WrittenByMe” 之類的空接口，然后讓你的所有類都實現它。然后給所有你用到的Java 內置類編寫包裝類。這里的思想是確保你程序里的每個對象都實現這個接口。最后，編寫所有的方法，讓它們的參數和返回類型都是這個 WrittenByMe。這樣就幾乎不可能搞清楚某個方法的功能是什么，并且所有類型都需要好玩的造型方法。更出格的玩法是，讓每個團隊成員編寫它們自己的接口(例如 WrittenByJoe)，程序員用到的任何類都要實現他自己的接口。這樣你就可以在大量無意義接口中隨便找一個來引用對象了。

巨型監聽器

永遠不要為每個組件創建分開的監聽器。對所有按鈕總是用同一個監聽器，只要用大量的 if…else 來判斷是哪一個按鈕被點擊就行了。

好事成堆TM

狂野地使用封裝和 OO 思想。例如

myPanel.add( getMyButton() );

private JButton getMyButton()

{

return myButton;

}

這段很可能看起來不怎么好笑。別擔心，只是時候未到而已。

友好的“朋友”

在 C++ 里盡量多使用 friend 聲明。再把創建類的指針傳遞給已創建類。現在你不用浪費時間去考慮接口了。另外，你應該用上關鍵字 private 和 protected 來表明你的類封裝得很好。

使用三維數組

大量使用它們。用扭曲的方式在數組之間移動數據，比如，用 arrayA 里的行去填充 arrayB 的列。這么做的時候，不管三七二十一再加上 1 的偏移值，這樣很靈。讓維護代碼的程序員抓狂去吧。

混合與匹配

存取方法和公共變量神馬的都要給他用上。這樣的話，你無需調用存取器的開銷就可以修改一個對象的變量，還能宣稱這個類是個”Java Bean”。對于那些試圖添加日志函數來找出改變值的源頭的維護代碼的程序員，用這一招來迷惑他尤其有效。

沒有秘密!

把每個方法和變量都聲明為 public。畢竟某個人某天可能會需要用到它。一旦方法被聲明為 public 了，就很難縮回去。對不？這樣任何它覆蓋到的代碼都很難修改了。它還有個令人愉快的副作用，就是讓你看不清類的作用是什么。如果老板質問你是不是瘋了，你就告訴他你遵循的是經典的透明接口原則。

全堆一塊

把你所有的沒用的和過時的方法和變量都留在代碼里。畢竟說起來，既然你在1976年用過一次，誰知道你啥時候會需要再用到呢？當然程序是改了，但它也可能會改回來嘛，你”不想要重新發明輪子”（領導們都會喜歡這樣的口氣）。如果你還原封不動地留著這些方法和變量的注釋，而且注釋寫得又高深莫測，甭管維護代碼的是誰，恐怕都不敢對它輕舉妄動。

就是 Final

把你所有的葉子類都聲明為 final。畢竟說起來，你在項目里的活兒都干完了，顯然不會有其他人會通過擴展你的類來改進你的代碼。這種情況甚至可能有安全漏洞。java.lang.String 被定義成 final 也許就是這個原因吧？如果項目組其他程序員有意見，告訴他們這樣做能夠提高運行速度。

避免布局

永遠不要用到布局。當維護代碼的程序員想增加一個字段，他必須手工調整屏幕上顯示所有內容的絕對坐標值。如果老板強迫你使用布局，那就寫一個巨型的 GridBagLayout 并在里面用絕對坐標進行硬編碼。

全局變量，怎么強調都不過分

如果上帝不愿意我們使用全局變量，他就不會發明出這個東西。不要讓上帝失望，盡量多使用全局變量。每個函數最起碼都要使用和設置其中的兩個，即使沒有理由也要這么做。畢竟，任何優秀的維護代碼的程序員都會很快搞清楚這是一種偵探工作測試，有利于讓他們從笨蛋中脫穎而出。

再一次說說全局變量

全局變量讓你可以省去在函數里描述參數的麻煩。充分利用這一點。在全局變量中選那么幾個來表示對其他全局變量進行操作的類型。

局部變量

永遠不要用局部變量。在你感覺想要用的時候，把它改成一個實例或者靜態變量，并無私地和其他方法分享它。這樣做的好處是，你以后在其他方法里寫類似聲明的時候會節省時間。C++ 程序員可以百尺竿頭更進一步，把所有變量都弄成全局的。

配置文件

配置文件通常是以 關鍵字 = 值 的形式出現。在加載時這些值被放入 Java 變量中。最明顯的迷惑技術就是把有細微差別的名字用于關鍵字和Java 變量.甚至可以在配置文件里定義運行時根本不會改變的常量。參數文件變量和簡單變量比，維護它的代碼量起碼是后者的5倍。

子類

對于編寫無法維護代碼的任務來說，面向對象編程的思想簡直是天賜之寶。如果你有一個類，里邊有 10 個屬性（成員/方法），可以考慮寫一個基類，里面只有一個屬性，然后產生 9 層的子類，每層增加一個屬性。等你訪問到最終的子類時，你才能得到全部 10 個屬性。如果可能，把每個類的聲明都放在不同的文件里。

6、編碼迷局

迷惑 C

從互聯網上的各種混亂C 語言競賽中學習，追隨大師們的腳步。（可參考《第 25 屆國際 C 語言混亂代碼大賽獲獎作品》的作品。）

追求極致

總是追求用最迷惑的方式來做普通的任務。例如，要用數組來把整數轉換為相應的字符串，可以這么做：

char *p;

switch (n)

{

case 1:

p = "one";

if (0)

case 2:

p = "two";

if (0)

case 3:

p = "three";

printf("%s", p);

break;

}

一致性的小淘氣

當你需要一個字符常量的時候，可以用多種不同格式：‘ ‘, 32, 0×20, 040。在 C 或 Java里 10 和 010 是不同的數（0 開頭的表示 16 進制），你也可以充分利用這個特性。

造型

把所有數據都以 void * 形式傳遞，然后再造型為合適的結構。不用結構而是通過位移字節數來造型也很好玩。

嵌套 Switch

Switch 里邊還有 Switch，這種嵌套方式是人類大腦難以破解的。

利用隱式轉化

牢記編程語言中所有的隱式轉化細節。充分利用它們。數組的索引要用浮點變量，循環計數器用字符，對數字執行字符串函數調用。不管怎么說，所有這些操作都是合法的，它們無非是讓源代碼更簡潔而已。任何嘗試理解它們的維護者都會對你感激不盡，因為他們必須閱讀和學習整個關于隱式數據類型轉化的章節，而這個章節很可能是他們來維護你的代碼之前完全忽略了的。

分號！

在所有語法允許的地方都加上分號，例如：

if(a);

else;

{

int d;

d = c;

}

;

使用八進制數

把八進制數混到十進制數列表里，就像這樣：

array = new int []

{

111,

120,

013,

121,

};

嵌套

盡可能深地嵌套。優秀的程序員能在一行代碼里寫 10 層 ()，在一個方法里寫 20 層 {}。

C數組

C編譯器會把 myArray[i] 轉換成 *(myArray + i)，它等同于 *(i + myArray) 也等同于 i[myArray]。高手都知道怎么用好這個招。可以用下面的函數來產生索引，這樣就把代碼搞亂了：

int myfunc(int q, int p) { return p%q; }

...

myfunc(6291, 8)[Array];

遺憾的是，這一招只能在本地C類里用，Java 還不行。

放長線釣大魚

一行代碼里堆的東西越多越好。這樣可以省下臨時變量的開銷，去掉換行和空格還可以縮短源文件大小。

記住，要去掉運算符兩邊的空格。優秀的程序員總是能突破某些編輯器對于 255 個字符行寬的限制。

異常

我這里要向你傳授一個編程領域里鮮為人知的秘訣。異常是個討厭的東西。良好的代碼永遠不會出錯，所以異常實際上是不必要的。不要把時間浪費在這上面。子類異常是給那些知道自己代碼會出錯的低能兒用的。在整個應用里，你只用在 main() 里放一個try/catch，里邊直接調用 System.exit() 就行了。在每個方法頭要貼上標準的拋出集合定義，到底會不會拋出異常你就不用管了。

使用異常的時機

在非異常條件下才要使用異常。比如終止循環就可以用 ArrayIndexOutOfBoundsException。還可以從異常里的方法返回標準的結果。

狂熱奔放地使用線程

如題。

測試

在程序里留些 bug，讓后來的維護代碼的程序員能做點有意思的事。精心設計的 bug 是無跡可尋的，而且誰也不知道它啥時候會冒出來。要做到這一點，最簡單的辦法的就是不要測試代碼。

永不測試

永遠不要測試負責處理錯誤、當機或操作系故障的任何代碼。反正這些代碼永遠也不會執行，只會拖累你的測試。還有，你怎么可能測試處理磁盤錯誤、文件讀取錯誤、操作系統崩潰這些類型的事件呢？為啥你要用特別不穩定的計算機或者用測試腳手架來模擬這樣的環境？現代化的硬件永遠不會崩潰，誰還愿意寫一些僅僅用于測試的代碼？這一點也不好玩。如果用戶抱怨，你就怪到操作系統或者硬件頭上。他們永遠不會知道真相的。

永遠不要做性能測試

嘿，如果軟件運行不夠快，只要告訴客戶買個更快的機器就行了。如果你真的做了性能測試，你可能會發現一個瓶頸，這會導致修改算法，然后導致整個產品要重新設計。誰想要這種結果？而且，在客戶那邊發現性能問題意味著你可以免費到外地旅游。你只要備好護照和最新照片就行了。

永遠不要寫任何測試用例

永遠不要做代碼覆蓋率或路徑覆蓋率測試。自動化測試是給那些窩囊廢用的。搞清楚哪些特性占到你的例程使用率的90%，然后把90%的測試用在這些路徑上。畢竟說起來，這種方法可能只測試到了大約你代碼的60%，這樣你就節省了40%的測試工作。這能幫助你趕上項目后端的進度。等到有人發現所有這些漂亮的“市場特性”不能正常工作的時候，你早就跑路了。一些有名的大軟件公司就是這樣測試代碼的，所以你也應該這樣做。如果因為某種原因你還沒走，那就接著看下一節。

測試是給懦夫用的

勇敢的程序員會跳過這個步驟。太多程序員害怕他們的老板，害怕丟掉工作，害怕客戶的投訴郵件，害怕遭到起訴。這種恐懼心理麻痹了行動，降低了生產率。有科學研究成果表明，取消測試階段意味著經理有把握能提前確定交付時間，這對于規劃流程顯然是有利的。消除了恐懼心理，創新和實驗之花就隨之綻放。程序員的角色是生產代碼，調試工作完全可以由技術支持和遺留代碼維護組通力合作來進行。

如果我們對自己的編程能力有充分信心，那么測試就沒有必要了。如果我們邏輯地看待這個問題，隨便一個傻瓜都能認識到測試根本都不是為了解決技術問題，相反，它是一種感性的信心問題。針對這種缺乏信心的問題，更有效的解決辦法就是完全取消測試，送我們的程序員去參加自信心培訓課程。畢竟說起來，如果我們選擇做測試，那么我們就要測試每個程序的變更，但其實我們只需要送程序員去一次建立自信的培訓課就行了。很顯然這么做的成本收益是相當可觀的。

7、編程語言的選擇

計算機語言正在逐步進化，變得更加傻瓜化。使用最新的語言是不人性的。盡可能堅持使用你會用的最老的語言，先考慮用穿孔紙帶，不行就用匯編，再不行用 FORTRAN 或者 COBOL，再不行就用 C，還有 BASIC，實在不行再用 C++。

FORTRAN

用 FORTRAN 寫所有的代碼。如果老板問你為啥，你可以回答說有很多它非常有用的庫，你用了可以節約時間。不過，用 FORTRAN 寫出可維護代碼的概率是0，所以，要達到不可維護代碼編程指南里的要求就容易多了。

用 ASM

把所有的通用工具函數都轉成匯編程序。

用 QBASIC

所有重要的庫函數都要用 QBASIC 寫，然后再寫個匯編的封包程序來處理 large 到 medium 的內存模型映射。

內聯匯編

在你的代碼里混雜一些內聯的匯編程序，這樣很好玩。這年頭幾乎沒人懂匯編程序了。只要放幾行匯編代碼就能讓維護代碼的程序員望而卻步。

宏匯編調用C

如果你有個匯編模塊被C調用，那就盡可能經常從匯編模塊再去調用C，即使只是出于微不足道的用途，另外要充分利用 goto, bcc 和其他炫目的匯編秘籍。

8、與他人共事之道

老板才是真行家

如果你的老板認為他 20 年的 FORTRAN 編程經驗對于現代軟件開發具有很高的指導價值，你務必嚴格采納他的所有建議。投桃報李，你的老板也會信任你。這會對你的職業發展有利。你還會從他那里學到很多搞亂程序代碼的新方法。

顛覆技術支持

確保代碼中到處是 bug 的有效方法是永遠不要讓維護代碼的程序員知道它們。這需要顛覆技術支持工作。永遠不接電話。使用自動語音答復“感謝撥打技術支持熱線。需要人工服務請按1，或在嘀聲后留言。”，請求幫助的電子郵件必須忽略，不要給它分配服務追蹤號。對任何問題的標準答復是“我估計你的賬戶被鎖定了，有權限幫你恢復的人現在不在。”

沉默是金

永遠不要對下一個危機保持警覺。如果你預見到某個問題可能會在一個固定時間爆發，摧毀西半球的全部生命，不要公開討論它。不要告訴朋友、同事或其他你認識的有本事的人。在任何情況下都不要發表任何可能暗示到這種新的威脅的內容。只發送一篇正常優先級的、語焉不詳的備忘錄給管理層，保護自己免遭秋后算賬。如果可能的話，把這篇稀里糊涂的信息作為另外一個更緊急的業務問題的附件。這樣就可以心安理得地休息了，你知道將來你被強制提前退休之后一段時間，他們又會求著你回來，并給你對數級增長的時薪！

每月一書俱樂部

加入一個計算機每月一書俱樂部。選擇那些看上去忙著寫書不可能有時間真的去寫代碼的作者。去書店里找一些有很多圖表但是沒有代碼例子的書。瀏覽一下這些書，從中學會一些迂腐拗口的術語，用它們就能唬住那些自以為是的維護代碼的程序員。你的代碼肯定會給他留下深刻印象。如果人們連你寫的術語都理解不了，他們一定會認為你非常聰明，你的算法非常深奧。不要在你的算法說明里作任何樸素的類比。

自立門戶

你一直想寫系統級的代碼。現在機會來了。忽略標準庫， 編寫你自己的標準，這將會是你簡歷中的一個亮點。

推出你自己的 BNF 范式

總是用你自創的、獨一無二的、無文檔的 BNF 范式記錄你的命令語法。永遠不要提供一套帶注解的例子（合法命令和非法命令之類）來解釋你的語法體系。那樣會顯得完全缺乏學術嚴謹性。確保沒有明顯的方式來區分終結符和中間符號。永遠不要用字體、顏色、大小寫和其他任何視覺提示幫助讀者分辨它們。在你的 BNF 范式用和命令語言本身完全一樣的標點符號，這樣讀者就永遠無法分清一段 (…), [...], {…} 或 “…” 到底是你在命令行里真正輸入的，還是想提示在你的BNF 范式里哪個語法元素是必需的、可重復的、或可選的。不管怎么樣，如果他們太笨，搞不清你的BNF 范式的變化，就沒資格使用你的程序。

推出你自己的內存分配

地球人都知道，調試動態存儲是復雜和費時的。與其逐個類去確認它沒有內存溢出，還不如自創一套存儲分配機制呢。其實它無非是從一大片內存中 malloc 一塊空間而已。用不著釋放內存，讓用戶定期重啟動系統，這樣不就清除了堆么。重啟之后系統需要追蹤的就那么一點東西，比起解決所有的內存泄露簡單得不知道到哪里去了！而且，只要用戶記得定期重啟系統，他們也永遠不會遇到堆空間不足的問題。一旦系統被部署，你很難想象他們還能改變這個策略。

9、其他偏門的招數

如果你給某人一段程序，你會讓他困惑一天；如果你教他們如何編程，你會讓他困惑一輩子。— 匿名網友

不要重編譯

讓我們從一條可能是有史以來最友好的技巧開始：把代碼編譯成可執行文件。如果它能用，就在源代碼里做一兩個微小的改動 — 每個模塊都照此辦理。但是不要費勁巴拉地再編譯一次了。你可以留著等以后有空而且需要調試的時候再說。多年以后，等可憐的維護代碼的程序員更改了代碼之后發現出錯了，他會有一種錯覺，覺得這些肯定是他自己最近修改的。這樣你就能讓他毫無頭緒地忙碌很長時間。

挫敗調試工具

對于試圖用行調試工具追蹤來看懂你的代碼的人，簡單的一招就能讓他狼狽不堪，那就是把每一行代碼都寫得很長。特別要把 then 語句 和 if 語句放在同一行里。他們無法設置斷點。他們也無法分清在看的分支是哪個 if 里的。

公制和美制

在工程方面有兩種編碼方式。一種是把所有輸入都轉換為公制（米制）計量單位，然后在輸出的時候自己換算回各種民用計量單位。另一種是從頭到尾都保持各種計量單位混合在一起。總是選擇第二種方式，這就是美國之道！

持續改進

要持續不懈地改進。要常常對你的代碼做出“改進”，并強迫用戶經常升級 — 畢竟沒人愿意用一個過時的版本嘛。即便他們覺得他們對現有的程序滿意了，想想看，如果他們看到你又“完善“了它，他們會多么開心啊！不要告訴任何人版本之間的差別，除非你被逼無奈 — 畢竟，為什么要告訴他們本來永遠也不會注意到的一些bug呢？

“關于”

”關于“一欄應該只包含程序名、程序員姓名和一份用法律用語寫的版權聲明。理想情況下，它還應該鏈接到幾 MB 的代碼，產生有趣的動畫效果。但是，里邊永遠不要包含程序用途的描述、它的版本號、或最新代碼修改日期、或獲取更新的網站地址、或作者的郵件地址等。這樣，所有的用戶很快就會運行在各種不同的版本上，在安裝 N+1 版之前就試圖安裝 N+2 版。

變更

在兩個版本之間，你能做的變更自然是多多益善。你不會希望用戶年復一年地面對同一套老的接口或用戶界面，這樣會很無聊。最后，如果你能在用戶不注意的情況下做出這些變更，那就更好了 — 這會讓他們保持警惕，戒驕戒躁。

無需技能

寫無法維護代碼不需要多高的技能。喊破嗓子不如甩開膀子，不管三七二十一開始寫代碼就行了。記住，管理層還在按代碼行數考核生產率，即使以后這些代碼里的大部分都得刪掉。

只帶一把錘子

一招鮮吃遍天，干什么就吆喝什么，輕裝前進。如果你手頭只有一把錘子，那么所有的問題都是釘子。

規范體系

有可能的話，忽略當前你的項目所用語言和環境中被普羅大眾所接受的編程規范。比如，編寫基于MFC 的應用時，就堅持使用STL 編碼風格。

翻轉通常的 True False 慣例

把常用的 true 和 false 的定義反過來用。這一招聽起來平淡無奇，但是往往收獲奇效。你可以先藏好下面的定義：

#define TRUE 0

#define FALSE 1

把這個定義深深地藏在代碼中某個沒人會再去看的文件里不易被發現的地方，然后讓程序做下面這樣的比較

if ( var == TRUE )

if ( var != FALSE )

某些人肯定會迫不及待地跳出來“修正”這種明顯的冗余，并且在其他地方照著常規去使用變量 var：

if ( var )

還有一招是為 TRUE 和 FALSE 賦予相同的值，雖然大部分人可能會看穿這種騙局。給它們分別賦值 1 和 2 或者 -1 和 0 是讓他們瞎忙乎的方式里更精巧的，而且這樣做看起來也不失對他們的尊重。你在Java 里也可以用這一招，定義一個叫 TRUE 的靜態常量。在這種情況下，其他程序員更有可能懷疑你干的不是好事，因為 Java 里已經有了內建的標識符 true。

第三方庫

在你的項目里引入功能強大的第三方庫，然后不要用它們。潛規則就是這樣，雖然你對這些工具仍然一無所知，卻可以在你簡歷的“其他工具”一節中寫上這些沒用過的庫。

不要用庫

假裝不知道有些庫已經直接在你的開發工具中引入了。如果你用VC++編程，忽略MFC 或 STL 的存在，手工編寫所有字符串和數組的實現；這樣有助于保持你玩指針技術的高水平，并自動阻止任何擴展代碼功能的企圖。

創建一套Build順序

把這套順序規則做得非常晦澀，讓維護者根本無法編譯任何他的修改代碼。秘密保留 SmartJ ，它會讓 make腳本形同廢物。類似地，偷偷地定義一個 javac 類，讓它和編譯程序同名。說到大招，那就是編寫和維護一個定制的小程序，在程序里找到需要編譯的文件，然后通過直接調用 sun.tools.javac.Main 編譯類來進行編譯。

Make 的更多玩法

用一個 makefile-generated-batch-file 批處理文件從多個目錄復制源文件，文件之間的覆蓋規則在文檔中是沒有的。這樣，無需任何炫酷的源代碼控制系統，就能實現代碼分支，并阻止你的后繼者弄清哪個版本的 DoUsefulWork() 才是他需要修改的那個。

搜集編碼規范

盡可能搜集所有關于編寫可維護代碼的建議，例如 SquareBox 的建議 ，然后明目張膽地違反它們。

規避公司的編碼規則

某些公司有嚴格的規定，不允許使用數字標識符，你必須使用預先命名的常量。要挫敗這種規定背后的意圖太容易了。比如，一位聰明的 C++ 程序員是這么寫的：

#define K_ONE 1

#define K_TWO 2

#define K_THOUSAND 999

編譯器警告

一定要保留一些編譯器警告。在 make 里使用 “-” 前綴強制執行，忽視任何編譯器報告的錯誤。這樣，即使維護代碼的程序員不小心在你的源代碼里造成了一個語法錯誤，make 工具還是會重新把整個包build 一遍，甚至可能會成功！而任何程序員要是手工編譯你的代碼，看到屏幕上冒出一堆其實無關緊要的警告，他們肯定會覺得是自己搞壞了代碼。同樣，他們一定會感謝你讓他們有找錯的機會。學有余力的同學可以做點手腳讓編譯器在打開編譯錯誤診斷工具時就沒法編譯你的程序。當然了，編譯器也許能做一些腳本邊界檢查，但是真正的程序員是不用這些特性的，所以你也不該用。既然你用自己的寶貴時間就能找到這些精巧的bug，何必還多此一舉讓編譯器來檢查錯誤呢？

把 bug 修復和升級混在一起

永遠不要推出什么“bug 修復”版本。一定要把 bug 修復和數據庫結構變更、復雜的用戶界面修改，還有管理界面重寫等混在一起。那樣的話，升級就變成一件非常困難的事情，人們會慢慢習慣 bug 的存在并開始稱他們為特性。那些真心希望改變這些”特性“的人們就會有動力升級到新版本。這樣從長期來說可以節省你的維護工作量，并從你的客戶那里獲得更多收入。

在你的產品發布每個新版本的時候都改變文件結構

沒錯，你的客戶會要求向上兼容，那就去做吧。不過一定要確保向下是不兼容的。這樣可以阻止客戶從新版本回退，再配合一套合理的 bug 修復規則（見上一條），就可以確保每次新版本發布后，客戶都會留在新版本。學有余力的話，還可以想辦法讓舊版本壓根無法識別新版本產生的文件。那樣的話，老版本系統不但無法讀取新文件，甚至會否認這些文件是自己的應用系統產生的！溫馨提示：PC 上的 Word 文字處理軟件就典型地精于此道。

抵消 Bug

不用費勁去代碼里找 bug 的根源。只要在更高級的例程里加入一些抵銷它的代碼就行了。這是一種很棒的智力測驗，類似于玩 3D 棋，而且能讓將來的代碼維護者忙乎很長時間都想不明白問題到底出在哪里：是產生數據的低層例程，還是莫名其妙改了一堆東西的高層代碼。這一招對天生需要多回合執行的編譯器也很好用。你可以在較早的回合完全避免修復問題，讓較晚的回合變得更加復雜。如果運氣好，你永遠都不用和編譯器前端打交道。學有余力的話，在后端做點手腳，一旦前端產生的是正確的數據，就讓后端報錯。

使用旋轉鎖

不要用真正的同步原語，多種多樣的旋轉鎖更好 — 反復休眠然后測試一個（non-volatile的）全局變量，直到它符合你的條件為止。相比系統對象，旋轉鎖使用簡便，”通用“性強，”靈活“多變，實為居家旅行必備。

隨意安插 sync 代碼

把某些系統同步原語安插到一些用不著它們的地方。本人曾經在一段不可能會有第二個線程的代碼中看到一個臨界區（critical section）代碼。本人當時就質問寫這段代碼的程序員，他居然理直氣壯地說這么寫是為了表明這段代碼是很”關鍵“（單詞也是critical）的！

優雅降級

如果你的系統包含了一套 NT 設備驅動，就讓應用程序負責給驅動分配 I/O 緩沖區，然后在任何交易過程中對內存中的驅動加鎖，并在交易完成后釋放或解鎖。這樣一旦應用非正常終止，I/O 緩存又沒有被解鎖，NT 服務器就會當機。但是在客戶現場不太可能會有人知道怎么弄好設備驅動，所以他們就沒有選擇（只能請你去免費旅游了）。

定制腳本語言

在你的 C/S 應用里嵌入一個在運行時按字節編譯的腳本命令語言。

依賴于編譯器的代碼

如果你發現在你的編譯器或解釋器里有個 bug，一定要確保這個 bug 的存在對于你的代碼正常工作是至關重要的。畢竟你又不會使用其他的編譯器，其他任何人也不允許！

一個貨真價實的例子

下面是一位大師編寫的真實例子。讓我們來瞻仰一下他在這樣短短幾行 C 函數里展示的高超技巧。

void* Realocate(void*buf, int os, int ns)

{

void*temp;

temp = malloc(os);

memcpy((void*)temp, (void*)buf, os);

free(buf);

buf = malloc(ns);

memset(buf, 0, ns);

memcpy((void*)buf, (void*)temp, ns);

return buf;

}

重新發明了標準庫里已有的簡單函數。

Realocate 這個單詞拼寫錯誤。所以說，永遠不要低估創造性拼寫的威力。

無緣無故地給輸入緩沖區產生一個臨時的副本。

無緣無故地造型。memcpy() 里有 (void*)，這樣即使我們的指針已經是 (void*) 了也要再造型一次。另外，這樣做可以傳遞任何東西作為參數，加10分。

永遠不必費力去釋放臨時內存空間。這樣會導致緩慢的內存泄露，一開始看不出來，要程序運行一段時間才行。

把用不著的東西也從緩沖區里拷貝出來，以防萬一。這樣只會在Unix上產生core dump，Windows 就不會。

很顯然，os 和 ns 的含義分別是”old size” 和 “new size”。

給 buf 分配內存之后，memset 初始化它為 0。不要使用 calloc()，因為某些人會重寫 ANSI 規范，這樣將來保不齊 calloc() 往 buf 里填的就不是 0 了。（雖然我們復制過去的數據量和 buf 的大小是一樣的，不需要初始化，不過這也無所謂啦）

如何修復 “unused variable” 錯誤

如果你的編譯器冒出了 “unused local variable” 警告，不要去掉那個變量。相反，要找個聰明的辦法把它用起來。我最喜歡的方法是：

i = i;

大小很關鍵

差點忘了說了，函數是越大越好。跳轉和 GOTO 語句越多越好。那樣的話，想做任何修改都需要分析很多場景。這會讓維護代碼的程序員陷入千頭萬緒之中。如果函數真的體型龐大的話，對于維護代碼的程序員就是哥斯拉怪獸了，它會在他搞清楚情況之前就殘酷無情地將他踩翻在地。

一張圖片頂 1000 句話，一個函數就是 1000 行

把每個方法體寫的盡可能的長 — 最好是你寫的任何一個方法或函數都不會少于1000行代碼，而且里邊是深度嵌套，這是必須的。

少個文件

一定要保證一個或多個關鍵文件無法找到。利用includes 里邊再 includes 就能做到這一點。例如，在你的 main 模塊里，你寫上：

#include

Stdcode.h 是有的。但是在 stdcode.h 里，還有個引用：

#include "a:\refcode.h"

然后，refcode.h 就沒地方能找到了。

（【譯注】為啥找不到呢？仔細看看，現在還有人知道 a: 是什么嗎？A盤！傳說中的軟盤…）

到處都寫，無處會讀

至少要把一個變量弄成這樣：到處被設置，但是幾乎沒有哪里用到它。不幸的是，現代編譯器通常會阻止你做相反的事：到處讀，沒處寫。不過你在C 或 C++ 里還是可以這樣做的。

【譯注】：英文在后面還有一些內容，翻譯時略有刪減。刪節的內容主要是：

我看不懂的部分;

我覺得不怎么好笑的部分（其實很可能是因為沒看懂所以找不到笑點）;

不容易引起現代程序猿共鳴的老舊內容。

本人水平有限，時間匆忙，難免有誤，請大家不吝指出。謝謝！