![\"\"](\"http:\/\/blog.adrianbolboaca.ro\/wp-content\/uploads\/2017\/11\/grenoble-live-remote-coding-1024x768.jpg\")
<\/a><\/p>\nDebriefing<\/h2>\n
At the end of the remote live coding session we had a remote discussion about what happened. Here is in form of Q&A.<\/p>\n
Question<\/strong>: When you want to show the duplication to be sure it is not accidental, you try to duplicate three times the same code. Do we need to do this when we do just copy\/paste? It doesn’t really help the tests.
\nAnswer<\/strong>: The fact that you can duplicate the test it shows it is easy enough and we don’t necessarily use the Rule of Three. But there are other cases when it’s more complicated and just duplicating the tests would not show the same. And there is still some duplication that doesn’t prove in the production code. We find that it’s not really the same behavior, and it’s often a surprise. The fact that I can make the duplication the third time is just making the point that we need to remove the duplication. Otherwise I need to search for duplication in another way.<\/p>\nQuestion<\/strong>: It seems that we create these tests just to follow the Rule of Three, not because we want to.
\nAnswer<\/strong>: I don’t want to create the tests just to follow the constraint of The Rule of Three, I just want to be sure enough that what I am doing is on the good path. I don’t want to rush into refactoring. It is a question of how well you know your domain and how much you trust your instincts. The TDD as if you Meant It comes with the idea you don’t trust your instincts and you need proof.<\/p>\nQuestion<\/strong>: If you want to create some duplication, we can use parametrized tests.
\nAnswer<\/strong>: Yes, for the tests that are duplicated we can use parametrized tests and compress the code. And probably at the end there will be very little code.<\/p>\nQuestion<\/strong>: Have you detected different styles of doing TDD
\nAnswer<\/strong>: Yes, but most of the problems I see that people fail to respect the rules and don’t find a way to respect the rules. But of course, there are very different styles. Some go very functional, some like to use more state, I go in very small steps. I like to go in very small steps and focus on triangulation. I like to use it as a machine that is generating duplication in all these tests and then because I have duplication, I extract the methods and the classes. You do need to refactor a lot. And you need very good tools to refactor automatically.<\/p>\nQuestion<\/strong>: I think this technique is a lot more difficult to use with Legacy Code, is it?
\nAnswer<\/strong>: Yes, it is more difficult. But you don’t need to use it too often with legacy code. I can use it on legacy code, but first of all I surround the code I want to change, put some interfaces around it, and then use the same steps to generate the code to rewrite it with very small steps in a simpler way. There might be situations where I prefer to rewrite some legacy code instead of refactoring. When using TDD as if you Meant It with legacy code you need to take very small steps, and do a lot of refactoring in small steps, understand the flow of dependency injection and understand the patterns. All these I learned by using TDD as if you Meant it a lot. I think it helps you to refactor better. You have this refactoring muscle. With legacy code you have a lot of primitives and so much misplaced code. Here with new code you have the same, and you need to understand how it makes sense to put it together. So I think you can use TDD as if you Meant It especially for the refactoring part.<\/p>\n<\/p>\n
Video<\/h2>\n
Check the video below with the codecast with remote live coding:<\/p>\n