COdE fr3@K

What Happens When We Lie to the Compiler?

2009-11-13T05:30:32Z

When you lie to your compiler, don’t be surprised to get results those differ from what you expect.

In this case, the coder promised his/her compiler the value of “value” won’t be changed, as it was declared const.

Therefore our best friend (yes, the compiler) who trusted the coder, thought “hey, I could cache this value in a register and not fetch it from RAM every time I reference it”, i.e. optimization.

If we change the code in the link slightly, so that function funcC would print *value before the assignment, one would see that the value of *value had actually been modified by function funcA. However, the modification was not visible in main, because the compiler was lied to as the coder explicitly told it that there would be no modification to value.

In the body of function funcC, though value was declared as a pointer to const instance, the compiler was smart enough to know it was lied to. There was a const_cast and a assignment, therefore, the modification to *value was reflected in the output.

Texas Army Base Rampage

2009-11-05T23:15:17Z

我的媽呀~~

在舊金山機場等回台北的飛機, 電視上不斷的播放著德州美軍基地內部發生槍擊的新聞.

CNN 目前的說法是: 連同兇手總共掛了 12 個人, 兇嫌是一名現役中校.

So, You Think C++ is Slower than C

2009-11-05T23:00:41Z

It is true that C++ provides programming constructs those consume more CPU cycles than it would when done without higher level of abstractions. But, hey, that’s the cost of abstractions, why pay when they are not needed?

Stop laying out your C++ design like Java. Avoid inheritance when possible. Don’t make every member function and destructor virtual without really thinking. They not only increase your run time overhead, they boost the complexity (read coupling) of your code like nothing else.

C++ does every C-style stuff the same way as C does. Not to mention it is capable of more compile time computation than C. I just fail to see how C++ could be slower than C in run time, seriously.

Boost.Lexical-Cast Alternatives

2009-09-22T03:05:15Z

今天稍早, 跟一位同事聊到 Boost 的 lexical_cast. 打開了 Firefox 請出 Google, 想找到能幫助我介紹 lexical_cast 的資源. 意外地, Google 把我帶到讓我賺了介紹獎金, 現在跟我是同事的 Jeff, 談到 lexical_cast 的文章.

在這篇文字的討論串, Jeff 寫道:

我覺得如果可以用這樣的寫法，那就太好了：
uint32_t ID = lexical_cast<auto>("1234567");
甚至最好是：
template <class From, class To = auto>
To lexical_cast(From s) {...}

uint32_t ID = lexical_cast("1234567");
Jeff Hung

小弟既然收了 Jeff 的好處, 當然得回報一下試著幫忙想想辦法:¹

PLAIN TEXT

C++:

#include <sstream>
#include <iostream>
#include <stdexcept>
class lexi_cast
{
public:
template <class Input>
lexi_cast(const Input& in)
{
ss_ <<in;
if(!ss_.good())
throw std::runtime_error("lexi_cast failed");
}
template <class Output>
operator Output()
{
Output out;
ss_>> out;
if(ss_.bad() || ss_.fail())
throw std::runtime_error("lexi_cast failed");
return out;
}
private:
std::stringstream ss_;
};
int main()
{
using namespace std;
// Converts C-style string to int.
int i = lexi_cast("123");
cout <<i <<endl;
// Converts int to std::string.
string s = lexi_cast(i);
cout <<s <<endl;
return 0;
}

岔題一下.

我一直不是很認同, 在 C++ 中, 以不同的規則來命名 class 與 function. 其中一個原因是, 這兩者的分野其實並沒有那麼大. 上面的 lexi_cast 就是一個很好的例子. 雖然它與 "真正" 的 function 相較仍有細微的不同, 但它的確是設計來讓使用者以 "function 風格" 操作的. 硬是把它的名字取得跟其他 function 格格不入, 豈不是很礙眼?

從另一個方面來看, 如果一個 class 的設計容易讓人把它錯誤地當作 function 使用, 而必須以命名原則來區分, 其設計者更是應該要好好反省.

看起來這似乎已滿足了 Jeff 的基本需求, 只是這全自動的轉換機制也有它的問題. 有些時候, 不提供更多資訊給 compiler, 就是會有 ambiguity. 例如 stream insertion:

PLAIN TEXT

C++:

// Ambigous! This won't compile!
cout <<lexi_cast(some_object);

Output stream 的 operator<< 有很多 overload. 由於 lexi_cast 提供了 generic 的 conversion operator, 因此 compiler 會找到多個可行 (viable) 的 overload. 若我們不顯性提示, compiler 會無法決定到底該採用哪個 overload. 這時候, lexi_cast 的全自動 (或說是缺乏手動指定的) 轉換功能反而變成了一種缺陷.

Attempt number 2. 簡單的把 lexi_cast 改成一個可以指定目的形別的 class template, 並配上做自動轉換的 default template parameter (struct auto_deduce) 以及 specialization:

PLAIN TEXT

C++:

struct auto_deduce {};
template <class Output = auto_deduce>
class lexi_cast2
{
public:
template <class Input>
lexi_cast2(const Input& in)
{
ss_ <<in;
if(!ss_.good())
throw std::runtime_error("lexi_cast2 failed");
}
operator Output()
{
Output out;
ss_>> out;
if(ss_.bad() || ss_.fail())
throw std::runtime_error("lexi_cast2 failed");
return out;
}
private:
std::stringstream ss_;
};
template <>
class lexi_cast2</*Output =*/auto_deduce>
{
public:
template <class Input>
lexi_cast2(const Input& in)
{
ss_ <<in;
if(!ss_.good())
throw std::runtime_error("lexi_cast2 failed");
}
template <class Output>
operator Output()
{
Output out;
ss_>> out;
if(ss_.bad() || ss_.fail())
throw std::runtime_error("lexi_cast2 failed");
return out;
}
private:
std::stringstream ss_;
};

效果並不理想. 自動轉換 (default behavior of class template lexi_cast2) 雖不需要指定 type, 但還是需要角括號 (angled bracket), 用起來醜到爆:

PLAIN TEXT

C++:

int main()
{
using namespace std;
// Note the next (commented) line won't compile,
// int i = lexi_cast2("123");
// Angled brackets needed for auto deduction.
// Not pretty at all.
int i = lexi_cast2<>("123");
cout <<i <<endl;
string s = lexi_cast2<>(i);
cout <<s <<endl;
// Now we could specify which "type" to convert to.
cout <<lexi_cast2<int>(s) <<endl;
return 0;
}

Attempt number 3. 下面的程式中的 class template lexi_cast3_helper 與 specialization 是從前面的 lexi_cast2 修改過來的. 只增加了 copy-ctor:²

PLAIN TEXT

C++:

template <class Output>
class lexi_cast3_helper
{
public:
template <class Input>
lexi_cast3_helper(const Input& in)
{
ss_ <<in;
if(!ss_.good())
throw std::runtime_error("lexi_cast3 failed");
}
// Copy-ctor. Needed for compilation, but not
// invoked at run-time.
lexi_cast3_helper(const lexi_cast3_helper& other)
{
ss_ <<other.ss_.str();
}
operator Output()
{
Output out;
ss_>> out;
if(ss_.bad() || ss_.fail())
throw std::runtime_error("lexi_cast3 failed");
return out;
}
private:
std::stringstream ss_;
};
template <>
class lexi_cast3_helper</*Output =*/auto_deduce>
{
public:
template <class Input>
lexi_cast3_helper(const Input& in)
{
ss_ <<in;
if(!ss_.good())
throw std::runtime_error("lexi_cast3 failed");
}
// Copy-ctor. Needed for compilation, but not
// invoked at run-time.
lexi_cast3_helper(const lexi_cast3_helper& other)
{
ss_ <<other.ss_.str();
}
template <class Output>
operator Output()
{
Output out;
ss_>> out;
if(ss_.bad() || ss_.fail())
throw std::runtime_error("lexi_cast3 failed");
return out;
}
private:
std::stringstream ss_;
};

把 lexi_cast3_helper 搭配上兩個 function template - 兩個 lexi_cast3 的 overload. 一個用來在自動轉換時躲避角括號 (angled bracket), 另一個讓使用者自行指定轉換的目的形別:

PLAIN TEXT

C++:

// Overload for output type auto deduction.
template <class Input>
lexi_cast3_helper<auto_deduce>
lexi_cast3(const Input& in)
{
return lexi_cast3_helper<auto_deduce>(in);
}
// Overload for user-specified output type.
template <class Output, class Input>
lexi_cast3_helper<Output>
lexi_cast3(const Input& in)
{
return lexi_cast3_helper<Output>(in);
}

結果是:

PLAIN TEXT

C++:

int main()
{
using namespace std;
// No ugly angled brackets for
// auto deduction of output type.
int i = lexi_cast3("123");
cout <<i <<endl;
string s = lexi_cast3(i);
cout <<s <<endl;
// User-specified output type.
cout <<lexi_cast3<int>(s) <<endl;
return 0;
}

這次看來就像樣多了. 能美美地做自動轉換, 也能自行指定轉換的目的形別.

The moral of this post - 果然還是 C++ 好玩!

[Update. Sep 22, 2009]

Improved and simplified. Per Jeff's request:

PLAIN TEXT

C++:

class lexi_cast4_helper
{
public:
template <class Input>
lexi_cast4_helper(const Input& in)
{
ss_ <<in;
if(!ss_.good())
throw std::runtime_error("lexi_cast4 failed");
}
// Copy-ctor. Needed for compilation, but not
// invoked at run-time.
lexi_cast4_helper(const lexi_cast4_helper& other)
{
ss_ <<other.ss_.str();
}
template <class Output>
operator Output()
{
Output out;
ss_>> out;
if(ss_.bad() || ss_.fail())
throw std::runtime_error("lexi_cast4 failed");
return out;
}
private:
std::stringstream ss_;
};
// Overload for output type auto deduction.
template <class Input>
lexi_cast4_helper lexi_cast4(const Input& in)
{
return lexi_cast4_helper(in);
}
// Overload for user-specified output type.
// Instead of returning conversion helper,
// this version returns output type.
template <class Output, class Input>
Output lexi_cast4(const Input& in)
{
return lexi_cast4_helper(in);
}

Sorry, Jeff. 明明是我自己愛玩卻還要遷拖到你. [↩]
由於 IOStream 是不能 copy 的, 因此 lexi_cast3_helper 需要有 copy-ctor 才能 compile. 有趣的是, 因為 RVO 的關係, 這些 copy-ctor 根本沒有 run-time 的用處, 不會被執行到. 可以把它的內容 comment 掉, 甚至亂改, 只要能 compile & link, 仍舊會正常運作. [↩]

Server side connection/session lingering

2009-08-17T02:45:07Z

A great read on how to properly teardown a connection of synchronous protocols (e.g. HTTP) on the server side.

via: SO_LINGER is not the same as Apache's "lingering close".

The C++0x “Remove Concepts” Decision

2009-08-12T12:52:37Z

懶人包 + Bjarne on DDJ (翻譯), from Paramecium.

Great job! Thanks, Keiko.

Avoid Leading Underscores

2009-07-25T10:08:11Z

在很多 code base 裏面都能看到在前面加個 underscore (底線/下滑线) 的 function/macro/variable. 常常是用來暗示某個 name 是 local/private, 有時是用來避免 name collision.

GoF 的經典巨著 Design Patterns 裏面, 以及一個時期的 Herb Sutter (the GURU), 都以在前面加上底線的方式標示 member data.

所有我見過的 Standard Library 的 implementation 不但都以在前面加個 underscore (底線/下滑线) 的方式命名 inclusion guard,¹ 也多用這方法替 member data 以及非公開的 identifier 起名字. Windows 則更是出了名的有許多在前面加了個 underscore 的標準 (documented) Win32 API.

可是關於 leading underscore, 標準是這麼說的: ²

Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

所有以 underscore 起頭的 identifier 都是保留給 compiler/standard library 實作任意使用的. 也就是說如果使用者自行定義了這樣的 identifier, 結果是無法預期的. 運氣好, 在 compile 時就得到 compiler error. 倒楣的話 undefined behavior 也不是不可能發生.

在實踐上, 這樣的 code 有很大的機會可以在你現在使用的 compiler 之下能正常編譯與運作, 但卻不能保證它就能在另一個 compiler (甚至是同一 compiler 的下一個版本) 之下也會得到相同的結果.³

日蝕

2009-07-22T03:54:39Z

老婆被我叫起床拍的照片.

C++0x – Concepts Rejected

2009-07-21T02:45:59Z

大件事, Concepts 被否決了.

Status Update, Mid 2009

2009-06-28T02:27:45Z

接下來幾個月, 打算把較多的閒暇時間用在一個 "低調計畫" 上. 因此, 預期將減少產出有意義的原創文字.

這個 project 當然是用 C++ 寫些東西. Scope 不大, 因此只要不擺爛, 一個人也一定寫得完. 簡單的說是要 re-implement 一個已存在並被不少人使用的 FOSS project. 將大量使用 Boost. 特別是已經一年多沒碰的 Asio, 以及很可惜一直沒玩到的 Multi-Index. 可以說是拿 Asio 來挑戰 libevent.

如果能較前人的貢獻有更好的 performance 當然最好. 即便不如期望, 也希望可以有機會找出不能 out-perform 的原因或線索. 或許能回饋給 Boost/Asio, 提供改善的方向. 無論如何, this is gonna be fun.

另, 如果你覺得閱讀小弟的文字不算是一件太浪費生命的事, 建議參觀/訂閱我的 Shared Items (via Google Reader).

STL Performance Boost in VS2010

2009-06-29T07:54:06Z

幾個月前曾在一篇文字裡寫道: 正確的運用 Rvalue References, 有可能帶來可觀的 performance gain. 前幾天看到 Visual C++ Team Blog 新貼出對 STL (VS2010 vs. VS2008) 的 performance benchmark. 在一個程度上, 該篇文字可以說驗證了這個不只我一個人獨有的看法與對 C++0x 的期待.

Rvalue-References 帶來的 performance boost 或許比不上 Multi-Core STL 來得那麼 "方便", 但絕對是你不會想要錯過的 low hanging fruit.

C++0x 的巨浪就要來了, 你準備好了嗎?

Wordpress Installation Upgraded

2009-06-25T12:11:49Z

成功把 wordpress 從 2.3.x 升級到 2.8. 照著官網上的說明一步一步做, 過程不算輕鬆但也不困難.

或許是因為本來就很陽春, foundation theme 似乎完全沒有問題, 這下沒那麼急迫需要換 theme 了.

考慮換成 Pixel theme, 慢慢改裝中.

Blog Pwnd, Again

2009-06-24T10:43:22Z

又被 hack 了, (上一次的紀錄) 這次的狀況跟這邊說的一樣. 準備升級至 Wordpress 2.8.

一直用的 foundation theme 早已是個孤兒沒有人維護, 換哪個 theme 才好呢?

The “Zw” Prefix

2009-06-05T03:02:07Z

I've always wondered: What does the "Zw" prefix (of some NT kernel functions) mean?

As it turns out - nothing.

It’s Better Without Asus

2009-05-30T11:07:02Z

Okay. Asus, this move is not cool.

Perhaps it's better without you, altogether. Bye.

Cited from: The Register.

Observer Pattern, Done Differently

2009-05-25T18:47:47Z

In a recent post of Scott Wheeler's - C and C++ are not the same language. He talked about differences between C and C++, and applications of different programming languages (C, C++, Java, Ruby) in his company.

In the post, Wheeler implemented observer pattern in C, C++ and Java, demonstrating some of his points - including how C and C++ are different from each other, and how C++ and Java are actually more alike.

Though I do agree with Wheeler's conclusion for the most part, I failed to share his view in C, C++ and Java comparison. IMHO, his observer implementation in C++ is rather old school, or should I say it's so Java.

In C++, oftentimes, there are more than one way to get you from point A to point B, while OO (inheritance) is the one feature that expresses coupling the most. In modern C++, when there is a way to do something without involving inheritance (read "tight coupling"), it is usually appreciated. One such way to implement the subject in observer pattern is:

Listing 1

PLAIN TEXT

C++:

class subject
{
public:
void register_observer(
const boost::function<void ()>& observer)
{
observers_.connect(observer);
}
void notify_observers() const
{
observers_();
}
private:
boost::signal<void ()> observers_;
};

With help from Boost, nothing from subject, (or the Listener interface used in Wheeler's implementation) except the signature of expected observers, are exposed to Observers (actually, the signature is exposed mostly to programmers). They are decoupled from each other. Next, let's see what types of observers can be utilized with this subject implementation:

Listing 2

PLAIN TEXT

C++:

class foo_observer
{
public:
void notify()
{
cout <<__PRETTY_FUNCTION__ <<endl;
}
};
class bar_observer
{
public:
bar_observer(unsigned int id)
: id_(id)
{}
void operator()()
{
cout <<__PRETTY_FUNCTION__ <<'[' <<id_ <<']' <<endl;
}
private:
unsigned int id_;
};
void free_observer()
{
cout <<__PRETTY_FUNCTION__ <<endl;
}

And how are they put together:

Listing 3

PLAIN TEXT

C++:

int main()
{
subject sub;
foo_observer foo;
bar_observer bar1(1);
sub.register_observer(
boost::bind(&foo_observer::notify, &foo));
sub.register_observer(bar1);
sub.register_observer(bar_observer(2));
sub.register_observer(&free_observer);
sub.notify_observers();
return 0;
}

This subject implementation can be used with general objects (e.g. foo_observer), functional objects (e.g. bar_observer), and of course free functions (e.g. free_observer) and more.

Don't be mistaken, though his C++ observer implementation is not among the best I've seen, Wheeler's post is nevertheless a good read. Enjoy.

Full source code: observer.cpp

My First JavaScript – Konami Code

2009-06-08T13:11:18Z

上週在我的 feed reader 上看到了個好玩的東西 - Konami Code.

原文作者引用了 jQuery 主站上的一段 JavaScript, 也明白的說了這個 script 的一個缺陷 - 隨著愈多的 keypress, 它會愈跑愈慢:

It’s a bit sloppy, though: the kkeys array will increase in size with every keypress, which means the page will get slower and slower as you press keys.

把 coding style 調整成自己比較習慣的風格, 加上幾行處理過多 user key log 的 code 以修正原文作者所說的問題, 補上了注解. Here it is, 我的第一個 JavaScript 程式:

PLAIN TEXT

JavaScript:

if(window.addEventListener)
{
var target = "http://fsfoundry.org/codefreak/2009/05/24/my-first-javascript-konami-code/";
var konami_code = "38,38,40,40,37,39,37,39,66,65";
var user_key_log = [];
var max_keys_to_log = 10;
window.addEventListener(
"keydown",
function(ev)
{
user_key_log.push(ev.keyCode); // push_back
var user_keys = user_key_log.toString();
// Searches for konami_code in user_keys.
if(user_keys.indexOf(konami_code)>= 0)
window.location = target;
// Cleans up user_key_log, if its length out
// numbered max_keys_to_log.
while(user_key_log.length> max_keys_to_log)
user_key_log.shift(); // pop_front
},
true);
}

只要你沒把 browser 的 JavaScript 關掉, 在 COdE fr3@K 的任何一頁輸入上上下下左右左右BA, 就會把你帶回到這篇文字.

Tested to work with:

Firefox 3.0.10
Opera 9.64
Epiphany Web Browser 2.24.1

Note: I don't know why, but as the original script from jQuery, my version doesn't work with IE 6 on my XP box at office.

Something interesting that I can't help wondering, 連我這個從沒認真看過 JavaScript 更別說寫過的人都能在知道問題後稍微 google 一下把這問題修掉, 難道 jQuery 網站的作者是覺得這段 code 純屬搞笑而隨便寫寫嗎?

I Like to Move It

2009-05-24T15:01:01Z

喜愛 C++ 並關心 C++0x 標準的朋友一定會知道, C++0x 引進了許多新的元素. 不但對 Standard Library 有為數眾多的 addition 與 enhancement, 連 core language 都新增了不少東西. 而其中最重要的, 在我看來, 就是 Rvalue References. 即便不理會 C++0x 其他的新玩意 Rvalue References 依然是一個職業 C++ programmer 該要掌握的新 feature. 原因很簡單, 正確的運用 Rvalue References, 有可能帶來可觀的 performance gain.

The Stage

兩週前, 在一篇文字中提到了一個因為貪玩寫下的 object 字串化/格式化 utility. 並預告了將在另一篇文字討論, 在 C++0x 的標準下如何對這個 utility 進行優化. Well, here it is. 先回頭看看原來的 code:

Listing 1

PLAIN TEXT

C++:

template <class T>
string str(const T& x)
{
return boost::lexical_cast<string>(x);
}
template <class T>
string operator%(string s, const T& x)
{
return s += str(x);
}

這個 utility 包含了兩個 function template. 使用方法如下:

Listing 2

PLAIN TEXT

C++:

string output = str(123) % ' ' % "abc";

簡單的說, 使用時需先以 function template str 觸發這字串化 utility, 接下來以另一個 function template - operator% - 串接繼續要被字串化的的 object.

The Problem

你知道簡單如 Listing 2 的 use case 會觸發幾次 string 的建構 (與解構) 嗎? 假設每次 lexical_cast 的 invocation 只會觸發一次 string instantiation. 在 compiler 進行了 RVO 之後, 仍有五次 string instantiation.


其中三次是建構從 str/lexical_cast 傳回的 string object,¹ 另外兩次是 operator% 返回時的 copy construction. 前者可說是無中生有,² 是躲不掉的開銷. 而後者兩次的 construction 雖然一樣是閃不掉, 但在 C++0x 的 Rvalue References 加持下, 其 copy 的 overhead 是可以避開的.

The Move
C++0x 的 Rvalue References 可說是為了達成 move semantics 而誕生的產物. 這裡的 move, 是把一個 object 管理的 resource 轉移到另外一個 object 身上的動作. 而 move construction, 則是把一個 object 的 resource 讓出來, 以創建另一個 object:

Listing 3
PLAIN TEXT
C++:




// a function that returns a temporary string.


string unnamed_source();


 


void move_construction_demo()


{


  // move-construct a string using unnamed source.


  string target(unnamed_source());


 


  string named_source(...);


 


  // move-construct another string using named source;


  string another_target(move(named_source));


 


  // "named_source" is now destructible, but not usable.


  // Any reference to it may result undefined behavior.


} 






請參考在之前的文字介紹過的一個字串 class 的 move constructor 以及 move function template 的 definition.
The Solution
有了 Rvalue References, 我們就可以把 Listing 1 的 operator% template 修改成:

Listing 4
PLAIN TEXT
C++:




template <class T>


string operator%(string s, const T& x)


{


  return move(s += str(x));


} 






在這個例子中, 只要在回傳前對 s += str(x) 的結果 - an lvalue (reference to a string) - 呼叫 move, 就能把原本的 copy construction 變成 move construction. 當然也避開了 copy 的開銷.
那為什麼不需要對另外一個 function template - str - 一併做 move? 由於來源是 rvalue (lexical_cast 的傳回值), 而 C++0x 的 string class 也有 move constructor. 在這組合的配合下, move 會自動發生. 即便 string class 沒有 move ctor, 從 lexical_cast 傳回的 string instance 也會被一路 RVO 到 str 的 caller,³ 其效果就跟被 move 了是十分接近的.
The Conclusion
C++0x 就要來了. 你能做的最好準備, 就是讓自己熟悉 Rvalue References. 它不是個 fancy feature, 而是能夠實實在在主宰程式的效能的 killer feature.
當 function 是以 return by value 方式傳回一個 named instance, 請記得: "We like to~~ MOVE IT!!!"

Full source code: move-it.cpp.
Compile using g++ 4.3.2: $ g++ -std=c++0x move-it.cpp

經過 RVO 之後, 已無法區分 str 與 lexical_cast 傳回的 instance. 兩者融為一體. [↩]
從沒有 string object 到有 string object. [↩]
至於這樣的 RVO 會不會真的發生, 就要看 compiler 優化的功力了. [↩]



New Job Openings at Work
2009-07-02T02:43:54Z
今天下午老闆的老闆跟我說, 他的手上也就是我現在服務的部門新增了二十個職缺, 並鼓勵我對外宣傳這個招兵買馬的訊息.
工作會是跟我同一個部門, 但應該不會是同一個 可能也有機會來我的 team. 細節還不清楚, 我就這個部門 common 的部份說明.
上班地點在台北市. 部門的主要責任是建置 cloud computing 的 infrastructure, 以及設計研發運行於這個 infrastructure 之上的 framework 與 application.
一定會用到的 hard skill 有:

Unix based. CentOS 5.3 is the choice of development and target platform of my team, choices among teams may vary.
System/network programming.
Proficiency at one or more of the following system programming languages; C, C++ and Java. There are teams, like mine, which does C++ mostly, and there are other teams those do Java or pure C.
Familarity with Free and Open Source Software. It would be foolish and arrogant if we were not to leverage existing and proven FOSS technologies when available. We use FOSS in conformance to their licenses.

還有一定會加分, 多數人遲早要用到, 但不是每個人都得現在就會的技術:

Knowledge in networking protocols. General TCP/IP and HTTP in particular. The more the better.
Distributed computing. e.g. distributed filesystem/database, MapReduce.
Relational database. e.g. PostgreSQL, MySQL.
Scripting. Most teams, if not all, use scripts. Just in case if you are curious, my team uses Perl for scripting.
Data mining.
Knowledge in Information Security.

不蓋你, 在個人這十年 software engineering 工作職涯裏, 就屬現在服務的公司最把軟體研發當一回事, 員工的福利也最好.
有興趣, 熱愛挑戰的朋友可以把履歷 email 給我.¹ 也歡迎把這個訊息轉告給其他的朋友. 轉貼時最好以 link 的方式進行, 以方便取得更新資訊.

連絡方式:

echo gsfbl.gtgpvoesz@psh | tr b-za.@ a-z@.


If you can't figure out my email address from the above code, you really shouldn't be emailing me. Sorry.

雖然小弟我沒有錄用與否的決定權, 但可以確保你的履歷被 forward 到正確的人手上, 免去被看不懂的人 filter 掉的風險. [↩]





Author of NoScript Apologized
2009-05-24T13:44:01Z
Giorgio (author of NoScript) apologized and explained things from a somewhat different (i.e. his) perspective.
As Giorgio said himself, it was wrong and there is no excuse. Though, from a user's point of view, I do not agree with his doings in this instance. However, from a geek's (i.e. my) point of view, they were not unthinkable.
My take, Giorgio was hacking, not for the greater good obviously, but there was no intention to takeover the world (or helping bad guys doing so) neither. That is if it is his true thinking that he told us.
For now, I am keeping NoScript.