好久不見。
最近重新登入這個 Blog，回頭看十多年前寫下的筆記，當時我還只是個菜鳥工程師。老實說，現在看到當時阿菜的我，寫的某些技術文章錯誤百出，真的是讓我想直接把文章刪了（笑）。
但我想了想，還是決定把這些舊文章留著。畢竟，那是我曾經在技術之路上跌跌撞撞、努力提升自己的紀錄。
這十多年來，我的人生軌跡發生了很大的變化。我從台灣到了矽谷工作，經過10多年的磨練，技術已經跟當年有天壤之別。去年，我卸下工程師的身份，轉職成為一名全職投資人。寫 Code 雖然能帶來收入，但學會「投資」，才能真正讓我們對人生擁有選擇權。
雖然戰場改變了，但過去身為工程師訓練出來的邏輯思維、對數據的敏感度，現在都成為我分析投資市場最重要的武器。
這個 Blog 未來不會再更新了。
我現在將所有的心力都投注在研究投資以及全世界資產佈局。如果你對投資感興趣，或者想看看一個前矽谷工程師是如何解析資本市場的，歡迎來我的投資筆記參觀：
最後，要特別感謝過去曾留言指正我錯誤的朋友們。你們的每一則留言我都看過，雖然無法一一回覆，但真心感謝當年的交流與指教。
doskey ls=dir
public static class StringHelper
{
public static bool IsCapitalized (this string s)
{
if (string.IsNullOrEmpty(s)) return false;
return char.IsUpper(s[0]);
}
}
IsCapitalized就是string type的extension method，我們可以這樣使用它：Console.WriteLine("Test".IsCapitalized());
其實這段呼叫在編譯時候會被修改成去呼叫static method，背後的細節被compiler隱藏起來。Console.WriteLine(StringHelper.IsCapitalized("Test"));
總結一下，extension method背後會做以下轉換：arg0.Method(arg1, arg2, ...); // Extension method call StaticClass.Method(arg0, arg1, arg2, ...); // Static method callInterface也可以被extended，範例如下：
public static T First(this IEnumerable sequence) { foreach (T element in sequence) return element; throw new InvalidOperationException("No elements!"); } ... Console.WriteLine("Test".First()); // Output: T
Python這類的動態語言大多提供Run-time時動態修改一個object的方法，這樣的好處是你可以動態的修改某個object，為這個Obejct加入一些新的method。
Ruby要為object加入新method非常簡單：
dog = Object.new
def dog.sit
print "I'm sitting.\n"
end
dog.sit
Ruby很簡單就能為dog加入一個sit的method。
Python實做起來稍微麻煩一些，主要原因是因為Python的函式有分成bound和unbound。
>>> def foo(): ... print "foo" ... >>> class A: ... def bar( self ): ... print "bar" ... >>> a = A() >>> foo <function foo at 0x00A98D70> >>> a.bar <bound method A.bar of <__main__.A instance at 0x00A9BC88>> >>>
bound method必須被bound到一個instance，在呼叫method時instance才會被當成參數傳入。
由於函式預設都是Unbound，如果直接加入method到object中，Python會丟出exception
>>> def barFighters( self ): ... print "barFighters" ... >>> a.barFighters = barFighters >>> a.barFighters() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: barFighters() takes exactly 1 argument (0 given)
其實只需要手動把method bound到instance上就可以解決這個問題。
這邊我們使用type module中的MethodType來把method bound到instance上。
>>> import types >>> a.barFighters = types.MethodType( barFighters, a ) >>> a.barFighters <bound method ?.barFighters of <__main__.A instance at 0x00A9BC88>> >>> a.barFighters() barFighters
可以看到method被bound後就可以在Python中被正確的呼叫，這就是Python動態在object加入method的方法。
Law of Demeter又叫做Least Knowledge，這其實是一個軟體設計的守則，簡單來說就是要簡單化Object之間的互動，讓多個Object不要互相相依。使得系統太過於複雜，造成未來維護成本較高。
Law of Demeter訂出了四條守則，限制一個Object內的函式只能呼叫以下這些函式：
不屬於以上這四種的函式都禁止呼叫。舉例來說，以下這個取得溫度的例子就違反Law of Demeter：
public float getTemp() {
return weatherStation.getThermometer().getTemperature();
}
以上的例子呼叫的getTemperature()函式是從getThermometer()中所取得，根據Law of Demeter的定義你不能使用某個透過其他函式回傳的物件中的函式。
public float getTemp() {
Thermometer thermometer = weatherStation.getThermometer();
return thermometer.getTemperature();
}
這個例子也同樣違反Law of Demeter，因為thermometer是透過其他Object的函式所取得。
public float getTemp() {
return weatherStation.getTemperature();
}
正解是在weatherStation中加入一個getTemperature()函式用來取得溫度。這樣就有符合Law of Demeter，因為weatherStation是此Object中包含的物件(HAS-A的關係)。
Law of Demeter可以減少Object之間的相依程度，可以減少軟體維護的成本。不過有優點就有缺點，使用此守則會產生出一些包裝用的函式，使用不當會導致開發速度增加，甚至會提昇軟體複雜度。
以下是一個過度包裝的例子，改成這樣雖然沒有違反Law of Demeter，但是沒有什麼意義。
public House {
WeatherStation station;
public float getTemp() {
Thermometer thermometer = weatherStation.getThermometer();
return getTempHelper(thermometer);
}
public float getTempHelper(Thermometer thermometer) {
return thermometer.getTemperature();
}
}
其實所有守則都不是強制的，守則是要對整體設計有益時才遵守。其實就和Design Pattern一樣，當你有需要時才使用。否則盲目的套用一堆OOP守則以及Design Pattern只會導致系統變得複雜，不容易理解。
Pluggable Object是最近在Kent Beck寫得TDD by example中所看到的Design Pattern。其實就是用多型來處理重複的判斷條件。Kent Beck在書中以圖片編輯器為例，在圖片上按下滑鼠左鍵並移動滑鼠表示拖曳圖片移動。而在空白的地方按下左鍵移動滑鼠會出現方框，讓你一次選取多張圖片。這個流程如果寫成程式碼會長得像這樣：
Figure selected;
public void mouseDown() {
selected= findFigure();
if (selected != null)
select(selected);
}
public void mouseMove() {
if (selected != null)
move(selected);
else
moveSelectionRectangle();
}
public void mouseUp() {
if (selected == null)
selectAll();
}
你會發現有許多重複的判斷條件，該怎麼避免呢？這時候就可以用Pluggable Object。
首先先定義一個Interface叫做SelectionMode，這個Interface會有兩個函式分別是mouseMove()以及mouseUp()，並且建立兩個class(SingleSelection, MultipleSelection)實做此Interface，分別處理單一選取圖片以及多重選取圖片。如此一來整個程式碼可以被改寫如下：
SelectionMode mode;
public void mouseDown() {
selected = findFigure();
if (selected != null)
mode = SingleSelection(selected);
else
mode = MultipleSelection();
}
public void mouseMove() {
mode.mouseMove();
}
public void mouseUp() {
mode.mouseUp();
}
程式碼變得乾淨整潔許多，這就是Pluggable Object。
工作狂不是英雄，真正的英雄已經回家了作者認為工作狂代表工作效率差，他們習慣用蠻力解決所有問題，而不去思考好的方法幫助自己提昇工作效率。這點也是我這幾年開始工作後的體會，同樣都是寫程式，高手會試著找尋好的方法來提昇自己的效率，像是使用快速鍵、好用的vim外掛，甚至是自己寫一些工具來改善工作效率。而一般人就如同作者寫得，習慣使用蠻力來解決所有問題，而不是動腦想更好的方法。
大家都知道goto對程式碼是有害的，會造成程式碼難以被看懂。不過goto並不完全沒有用，有些情況使用goto會讓程式碼看起來比較清楚。
由於C的語法沒有例外處理，在處理錯誤時有很多種寫法，我個人覺得使用goto的這個寫法的可讀性比較好。這也是目前我唯一想到適合使用goto地方，你可以在Linux kernel的程式碼中時常看到這種用法：
void foo()
{
if (!doA())
goto exit;
if (!doB())
goto error;
if (!doC())
goto error;
/* everything has succeeded */
return;
error:
/* error recovering */
exit:
return;
}
另一個常用的範例是用來release resource，以下程式碼當檢查vector中的資料是錯誤時，會使用goto跳到release resource的程式碼。
double sum_vector(double *vector1, double *vector2, int *error) {
double sum = 0;
*error = 1;
if(!checkVectorValid(vector1)) goto invalidVector;
if(!checkVectorValid(vector2)) goto invalidVector;
/* sum of vectors */
*error = 0;
invalidVector:
free(vector1);
free(vector2);
return 0;
}
fileReader.DiscardBufferedData(); fileReader.BaseStream.Seek(0, SeekOrigin.Begin); fileReader.BaseStream.Position = 0;
int? x = null; int y = x ?? 5; // y is 5first ?? second語法被執行的步驟如下：
int? a = null, b = 1, c = 2; Console.WriteLine (a ?? b ?? c); // 1善用?? operator可以讓我們的程式碼變得更簡潔，以下是一個範例程式用來計算使用者的年紀，這個例子沒有使用?? operator。
DateTime birth;
DateTime? death;
public TimeSpan Age
{
get
{
if (death == null)
{
return DateTime.Now - birth;
}
else
{
return death.Value - birth;
}
}
}
使用?? operator我們可以把上面的範例改寫成好懂又精簡的版本。
DateTime birth;
DateTime? death;
public TimeSpan Age
{
get
{
DateTime lastAlive = death ?? DateTime.Now;
return lastAlive – birth;
}
}
C#從4.0版之後開始支援optional parameters以及named arguments，這兩個語法通常會一起使用。他讓我們的程式碼變得更簡潔並增加可讀性。首先先來介紹什麼是Parameters and Arguments。
Parameters和Arguments是兩個很容易搞混的名詞，先來定義這兩者有什麼不同。下面是一段程式碼範例：
void Foo(int x, int y)
{
// Do something with x and y
}
...
int a = 10;
Foo(a, 20);
parameters是function定義時所使用的變數，arguments是我們呼叫function時傳進去的變數或值 範例中的x和y是parameters，a和20是arguments。
Optional parameters簡單說就是給parameter一個特定的預設值，當使用者沒有傳入此parameter所對應的arguments時，會自動使用預設值。在C#4.0之前沒有optional parameters，如果要達到這個功能必須使用overloading function，會造成寫一大堆overloading function的情況，並不是很好使用。C#4.0之後使用optional parameters可以免去宣告一堆overloading function的困擾。以下是optional parameters的一個簡單範例:
static void Dump(int x, int y = 20, int z = 30)
{
Console.WriteLine("x={0} y={1} z={2}", x, y, z);
}
...
Dump(1, 2, 3);
Dump(1, 2);
Dump(1);
我們設定y和z的預設值為20和30，當我們在呼叫function時，編譯器會根據我們提供的參數去做對應，找出最合適的function。程式執行結果如下：
x=1 y=2 z=3 x=1 y=2 z=30 x=1 y=20 z=30
程式會從parameters list的左邊到右邊一一去對應參數。如果出現無法對應的情況會丟出exception。
由於optional parameters和arguments的對應是按照宣告的順序，因此當我們呼叫Dump(1, 2)時會自動把y對應成2，沒辦法把2對應到z讓y使用預設值。要讓參數能自由對應需要使用接下來要介紹的named arguments。
parameter的預設值必須是一個常數，因此以下範例是錯誤的，因為DataTime.Now並不是一個常數。Foo(DateTime dt = DateTime.Now)
Optional parameters也被限制必須放在後面，不能放在非optional parameters之前。
Foo(int x = 0, int y)
Name arguments讓我們可以不按照順序傳入參數。他的語法是在argument前加入一個對應parameter的名稱。以下是範例：
static void Dump(int x, int y, int z)
{
Console.WriteLine("x={0} y={1} z={2}", x, y, z);
}
...
Dump(1, 2, 3);
Dump(x: 1, y: 2, z: 3);
Dump(z: 3, y: 2, x: 1);
Dump(1, y: 2, z: 3);
Dump(1, z: 3, y: 2);
不管argument的順序是如何，編譯器會自動幫我們對應到正確的parameters名稱。
x=1 y=2 z=3 x=1 y=2 z=3 x=1 y=2 z=3 x=1 y=2 z=3 x=1 y=2 z=3
int i = 0; Dump(z: ++i, x: ++i, y: ++i);
x=2 y=3 z=1
上面這行程式碼輸出的結果可能會和你想的不一樣，這是因為傳進去的argument還是根據他宣告的順序做計算，而不是patameters的順序。我們應該要避免寫出這種程式碼。
<PropertyGroup Label="Globals">
...
<RootNamespace>...</RootNamespace>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
</PropertyGroup>
>>> import dis
>>> def foo():
... a = 1
... b = 2
... c = a + b
...
>>> dis.dis(foo)
2 0 LOAD_CONST 1 (1)
3 STORE_FAST 0 (a)
3 6 LOAD_CONST 2 (2)
9 STORE_FAST 1 (b)
4 12 LOAD_FAST 0 (a)
15 LOAD_FAST 1 (b)
18 BINARY_ADD
19 STORE_FAST 2 (c)
22 LOAD_CONST 0 (None)
25 RETURN_VALUE
dis module中的dis method可以幫助你把Python code轉成byte code
newCode(); /* someOtherCode(); */
/* newCode(); */ someOtherCode();其實可以用C裡頭preprocessor的小技巧來快速切換程式碼
#if 1 newCode(); #else test(); /* FIXME: please don't to that. */ someOtherCode(); #endif
#if 0 newCode(); #else test(); /* FIXME: please don't to that. */ someOtherCode(); #endif如此一來我們只要切換1和0就可以快速切換不同區塊的程式碼，就算裡頭有註解也不用擔心
#if 0 newCode(); test(); #endid
如果一個程式語言中的每個變數型別在編譯時期就完全決定好，我們稱這個程式語言屬於static type。這類的程式語言在使用變數時通常都需要先宣告變數，編譯器會在編譯時期去做type checking。比如說Java, C, C++, C#。以下是一段C的範例:
int num, sum; // explicit declaration num = 5; // now use the variables sum = 10; sum = sum + num;
變數使用前需要宣告是static type的特徵之一
Dynamic type和static type相反，一個屬於dynamic type的程式語言不需要宣告變數，因此編譯器無法對型別做檢查在編譯時找出型別上的錯誤。在執行期間存取變數時，會透過適當的機制來判斷此變數可能的型別。Dynamic type不需要事先宣告變數就能直接使用，比如說Python, PHP, Ruby, Perl。以下是一段Python的範例程式:
sum = 1 // directly using the variable sum += 2
上面的範例我們直接使用變數sum而沒有事先宣告，這是dynamic type的其中一個特徵。 簡單來說，Static typing會在編譯時去做type checking。而dynamic type會在run-time時做check。
Strong typing很常會和static typing以及dynamic typing搞混。Strong typing是指變數會被綁定到某個型別，除非經過明顯的型別轉換，不然型別不會任意改變。比如說Python就是strong typing，以下是個範例:
>>> x = 3 >>> y = '4' >>> print(x+y) Traceback (most recent call last): File "", line 1, in TypeError: unsupported operand type(s) for +: 'int' and 'str'
Python不允許int和string相加，除非我們主動去做型別轉換，不然x和y變數不會經過隱藏的型別轉換加在一起。這就是Strong typing的主要特徵。Python是dynamic typing同時也是strong typing
Weak typing是指型別的概念比較弱，變數的型別可能隨時會經過隱性的轉換。比如說JavaScript，以下是JavaScript的範例:
var x = 3 var y = '4' alert(x + y) //Produces "34"
不同於Python，JavaScript允許這種語法並且會自動幫你做型別轉換。這就是weak typing的特徵之一。
其實這兩者並沒有一個約定成俗的定義，很多程式語言都同時有兩種的特性。只能說偏向某一邊比較多。比如說C，大部分人認為C偏向Weak Typing，因為C有pointer可以做任意轉型，同時也有void *這種變數可存取任意型別。
int i = 10; char *s = (char*)i; print(*(s+10));這種問題不會發生在C#身上，因為C#是Type-safe的程式語言。以下範例在C和C++合法，但是在C#會丟出錯誤訊息：
double d = 10.59; int i = 5; i = d; //this causes an Error在C#中不能隨便把某個型別的資料當作是另外一種型別，如果編譯器認為這樣轉型是不合法的，在編譯的時候就會丟出錯誤。
using System;
delegate void StringProcessor(string input);
class Person
{
string name;
public Person(string name) { this.name = name; }
public void Say(string message)
{
Console.WriteLine("{0} says: {1}", name, message);
}
}
class SimpleDelegateUse
{
static void Main()
{
Person jon = new Person("Jon");
Person tom = new Person("Tom");
StringProcessor jonsVoice, tomsVoice;
jonsVoice = new StringProcessor(jon.Say);
tomsVoice = new StringProcessor(tom.Say);
jonsVoice("Hello, son.");
tomsVoice.Invoke("Hello, Daddy!");
}
}
此範例中我們建立了宣告了兩個delegate的instance，分別是jonsVoice以及tomsVoice。最後用兩種不同的方式呼叫functiondelegate void StringProcessor(string input);這行就是我們宣告delegate type的地方，這個delegate的type是含有一個string參數且回傳值為void的function。此delegate type只能接受回傳值以及參數個數一模一樣的function。不過有一種特殊情況：
void Test(object x);此function也可以被assigned給此delegate的instance，因為string是繼承自object
StringProcessor jonsVoice, tomsVoice; jonsVoice = new StringProcessor(jon.Say);用new可以建立剛才宣告好得delegate instance，建立傳入的參數是之後要透過delegate呼叫的function
void HowAreYou(string sender) {
Console.WriteLine("How are you, " + sender + '?');
}
void HowAreYouToday(string sender) {
Console.WriteLine("How are you today, " + sender + '?');
}
Notifier greetMe;
greetMe = new Notifier(HowAreYou);
greetMe += new Notifier(HowAreYouToday);
greetMe("Leonardo"); // "How are you, Leonardo?"
// "How are you today, Leonardo?"
greetMe -= new Notifier(HowAreYou);
greetMe("Pereira"); // "How are you today, Pereira?"
File.ReadAllText(path) // (回傳string) File.ReadAllLines(path) // (回傳array of strings) File.ReadAllBytes(path) // (回傳一個byte array)
File.WriteAllText(path, string) File.WriteAllLines(path, array of strings) File.WriteAllBytes(path, bytes) File.AppendAllText(path, string) // (適合用在log file)File.ReadAllLines和File.ReadLines看起來很像，但是ReadAllLines會一次把所有資料讀到記憶體中