1 TDD is design process; it let you design for testing, naturally

Write the test firstly, it does not only help you find the bugs; but the most important point is to let you design for test naturally.

Also you should keep in mind, tests not only help you find bugs, but also protect your codes; when some changes impact on your existing codes, the tests will be broken.

2 Keep the implementation simple

Keep your implementation simple, just let the test pass. The complex implementation may introduce the logics or codes not covered by the tests, even leads some codes not testable.

3 TDD in each scope.

You may get to know the concept ATDD (acceptance test driven development). TDD could be used in every phase of the development and by the different granularity.

To ATDD, you could consider on using some existing framework such as FIT, these frameworks will be bridge between business logic and implementation logic.

Recently, the concept BDD (behavior driven development) is introduced to the ATDD process, so the BDD frameworks such as JBehave is also the good choice.

Different TDD process could be nested and should be nested don’t let your step too large.

4 keep each step small enough

Always keep each step small to avoid introducing the untestable codes or logics and pass each test quickly.

6 Always refactor

This step is always overlooked in TDD process; however it is the very important step. Also, never forget refactor should involve all your tests.

Why can't write test firstly?

 1.not think how to meature the codes

2. The current step maybe too large, should separate into small ones

3. The codes with ugly dependencies

 http://blog.csdn.net/chaocai2004/archive/2011/01/09/6125479.aspx

Chao Cai (蔡超)

Sr. SDE

Amazon.com

以前在学习算法和数据结构的时候，对于每种算法的复杂度都是死记的并没有真正的去研究他们是如何计算出来，最近突然对算法产生了兴趣，迫使自己研究了一下算法复杂度的计算方法。

概念

大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。

另外除了这个官方概念，个人认为大O表示的是问题规模n和算法中语句执行次数的关系。

以二分查找为例，我们求解它的时间复杂度

1 设规模为n个元素时，要执行T(n)次

T(n)=T(n/2)+1

T(n)=[T(n/4)+1]+1

…

T(n)=T(n/2^m)+m

当n=2^m

T(n)=T(1)+log2n

T(1)=1

所以其算法复杂度为O（log2n）