Misuse of Inheritance in Web Controllers

Inheritance is a common feature in OOP languages to specialise classes/types and allows polymorphism. It is easy to reuse the common functionality between classes by moving it to the parent class and use by the child classes. Without being mindful of software design principles, it can lead to increased coupling and responsibilities, making existing code hard to change. We’ll take you through a situation in C# MVC’s controllers and show how it improves the design by refactoring. The class diagram shown illustrates a fictitious online photo stock website.

misuse-inheritance-1 class diagram before refactor

This is a violation of interface segregation principle (ISP) which states that no client should be forced to depend on methods it does not use. In this case, BaseController has multiple methods and through inheritance, all of the child controllers have access to them but only use some of them and does not need some of them. When there’s a change in BaseController’s GetCredit, the child controllers which use it might be affected and should be checked and tested.

Continue reading

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(https://www.facebook.com/pg/91agile/about/?ref=page_internal). 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.
    e.g.
    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 (http://blog.jbrains.ca/permalink/becoming-an-accomplished-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

Untitled

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_lynne_cazaly

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