Pair Programming in Recruitment – The Titansoft Way


pair programming

As James Shore says of pair programming in his eponymous blog, “It’s more fun than it sounds: two programmers at one computer. One drives; the other navigates. Switching roles fluidly, they constantly communicate. Together, they accomplish better work more quickly than either could alone.” Teamwork never sounded so poetic.

Titansoft is an Agile organisation and we have been practicing pair programming since 2014. And having experienced the benefits of this practice, we are extending it to out Recruitment process. Having a programming session with a potential candidate is only one part of the hiring puzzle, but it’s often the most important one. Rather than looking at the CV and asking a long list of questions, which may not be as effective, we get around recruitment for our Senior Software Developers by holding a pair programming session. We believe that the pair programming process creates a better opportunity to showcase a coder’s skill.

“Through pair programming, our developer can know more about how the candidate behaves during real work such as his working style, coding preference, discussion etc. In addition, we are also able to show the candidate the way our company people code.”

Ji Zhoubo – Senior Software Developer in Titansoft

Continue reading

TDD Training by JBrains

This is the second formal TDD training I have joined (The first one was conducted by Joey Chen( I could not find online line 😦  sad..). I would like to share some “Aha” moments along the way of this training.

Before that, allow me to share how i took the training(The first 2 series, which is free 🙂 ):

  1. For 1st series, I implement without TDD first. The reason why I do that is I am just very curious of what is the time difference and other difference if i am lucky to find out.
  2. For 2nd series, I just follow the video and stop where ever I need to think or research or take notes.


Ok. That’s enough. Let’s go to the my “Aha Wow” moments:

  1. Really step by step by step : Fail -> Add Logic -> Pass -> Commit -> Refactor
  2. It’s developers responsibility to cover more tests than the general requirements from clients. (I mention this because I have an assumption from my first TDD training that developers only need to add tests based on the requirements. )
  3. Avoid more complex integration test by adding unit test when small class or methods come out along the way of implementation.
  4. Triangulation concept somehow makes me feel better compare to one of TDD rules: You are not allowed to write any more production code than is sufficient to pass the one failing unit test. Because when ever I try to hardcode to make the test I feel so bad and keep wondering why not find the basic logic 1st.
  5. Multilevel of abstraction code smell apply not only to same functionality, but also all same level functionality with different purpose.
    Assume inside one function, there is one logic related to getPrice, three logic related to display price. We should abstract both the getPrice logic and the displayPrice logic to achieve same level of abstraction for easy reading and maintaining.
  6. Duplicated Concepts/Ideas: Do not repeat your self is not only about code, but also the way of covering the logic.
    e.g. if  A else if B else if C …. is one example of duplicated ideas
  7. Intuitive and Mechanical approach of software designer (
  8. Refactoring based on single responsibility. Re-assign responsibility makes the code much more flexible and clear. For this I am not able to express it clearly by tying here. I strongly suggest you take the 2nd series of the training. Then you may feel it more.


“Post-Credit Scene”:
For my little test “For 1st series, I implement without TDD first.”, I did it within 15mins including the tests, while the training took more than one hour. But the test cases are much more less. Reason: I understand the logic of fraction adding. So my test only focus on the logic and with few special cases. I feel some tests inside the 1st series training are duplicated. So until now, I believe that TDD can help design the code but not necessarily helpful in every development scenario.

7 Key Factors for Agile Testing


Janet Gregory at the Titansoft office!

A couple of months ago, we invited Janet Gregory to our company for a sharing on Agile Testing. Janet is the co-author of the Agile Testing book. One of the key take away from the sharing was testing is an activity throughout the sprint. It’s not a phase where testing can started after development is done. In addition, she also mentioned 7 key factors for an Agile testing which I found really interesting.

Continue reading

12 Best Agile Blogs to Follow


Agile Manifesto by Lynne Cazaly

Similar to the idea of continuous improvement in Agile Development, we believe that we constantly need to broaden our Agile knowledge. These 12 Agile blogs are the ones that I personally follow and read frequently (with no particular order). For me, the good point for reading other sources is that I can learn to be more adaptive – if I stumble in my current way of doing Agile, I can learn from other people’s experiences and try to adapt it into my own development.

Continue reading

A little secret to Scrum Master Survival

Developers produce code, testers produce quality, and what does a ScrumMaster produce then? A well working team is a common answer for question above. In my opinion, finding what to do is hard, yet finding how to do it properly is even harder. There are ton of articles out there which can tell you what you should be doing as a ScrumMaster, but not much of them will tell them how to do it right. Why? Because we all reckon in order to advise how things can be right, you have to experiment within the contexts. In this post, I will share some of my thoughts and learning since I have switched my role as to ScrumMaster.
Continue reading