This is a remote pair programming codecast with Wassel Alazhar on an interesting problem called Good Friends.
After implementing a bit of the problem, we discuss about what we have done. We observe a lot of duplication and we debrief.
This is a remote pair programming codecast with Wassel Alazhar on an interesting problem called Good Friends.
We pick a problem not at all known by me and we figure it out with #TDD on first view. Interesting to see how you need to analyze before rushing to write tests
Evolutionary Design Talk Evolutionary Design: The art of growing a system by observing its natural traits and then normalizing and optimizing its growth Evolutionary Design seems to be one of the black arts of software…
Evolutionary Design is the practice of growing a system in a natural way, by adding the minimum amount of code to satisfy the business needs in an iterative and incremental approach. When done right, the code structure changes continuously to optimize for change, thus allowing a constant speed of development for longer periods of time.
In a dynamic world we need to adapt our tools and techniques to be resilient to change. Evolutionary Design is one of these techniques that helps us grow a system well by understanding its current characteristics.
Please see more of my ideas on the topic of Evolutionary Design here. During this article I will explain that there is an obvious parallel between Software Evolutionary Design and Organizational Evolutionary Design.
Evolutionary Design is the practice of growing a system in a natural way, by adding the minimum amount of code to satisfy the business needs in an iterative and incremental approach. When done right, the code structure changes continuously to optimize for change, thus allowing a constant speed of development for longer periods of time.
In a dynamic world we need to adapt our tools and techniques to be resilient to change. Evolutionary Design is one of these techniques that helps us grow a system well by understanding its current characteristics.
Episode 6 of this #RemotePairProgramming series is about Evolutionary Design with Selection Pressure. My coding pairing partner this episode is Julian Ghionoiu
Selection Pressure. What is it?
What is Selection Pressure? First of all let’s give a definition from Biology
Any cause that reduces reproductive success in a portion of a population potentially exerts evolutionary pressure, selective pressure or selection pressure.[1] With sufficient pressure, inherited traits that mitigate its effects — even if they would be deleterious in other circumstances — can become widely spread through a population. It is a quantitative description of the amount of change occurring in processes investigated by evolutionary biology, but the formal concept is often extended to other areas of research.
During this episode we will apply the concept of Selection Pressure from Biology to software development that Julian Ghionoiu came-up with. So check the video to see more!
The third episode of this #RemotePairProgramming series is about Evolutionary Design with Selection Pressure. And, as always, I have coding coding pairing partner, that during this episode is Julian Ghionoiu.
At SoCraTes France I paired with Rémy and Johan to show them how I code using TDD as if you Meant It. We had a few hours to try it, and then Rémy told me he would like me to present this to the Grenoble Software community. So this is how we arranged a remote live coding session on TDD as if you Meant It.
During this session I am using Poker Hands as a problem, and I start with the usual Think-Red-Green-Refactor and Behavior Slicing. Then a lot of refactoring is going on. I invite you to watch the video and come with questions and improvement ideas.
At the end of the remote live coding session we had a remote discussion about what happened. Here is in form of Q&A.
Question: 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.
Answer: 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.
Question: It seems that we create these tests just to follow the Rule of Three, not because we want to.
Answer: 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.
Question: If you want to create some duplication, we can use parametrized tests.
Answer: 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.
Question: Have you detected different styles of doing TDD
Answer: 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.
Question: I think this technique is a lot more difficult to use with Legacy Code, is it?
Answer: 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.
After in the previous episode I took too bigger steps, during this episode I start all over and take smaller steps. The main differences are:
TDD as if you Meant It: Clean-up before next Triangulation (Episode 13) About This episode is about failure to refactor because of trying to rush to the next step of Triangulation and taking too bigger…
TDD as if you Meant It: Separate Production from Test Code (Episode 12) About When using TDD as if you Meant It we need to have a clear distinction between the test code, and the…
TDD as if you Meant It: Refactor and Clean-Up (Episode 11) About From Wikipedia we learn that Code refactoring is the process of restructuring existing computer code—changing the factoring—without changing its external behavior So clearly not any…