In a previous post we talked about positional parameters and how they can suffer from Connascence of Position, (CoP). Then we saw how, in some cases, we might introduce named parameters to remove the CoP and transform it into Connascence of Name, (CoN), but always being careful to not hiding cases of Connascence of Meaning, (CoM). In this post we'll focus on languages that don't provide named parameters and see different techniquess to remove the CoP.
Let's see an example of a method suffering of CoP:
In languages without named parameters (the example is written in Java), we can apply a classic refactoring technique, Introduce Parameter Object, that can transform CoP into CoN. In this example, we introduced the ClusteringParameters object:
which eliminates the CoP transforming it into CoN:
In this particular case, all the parameters passed to the function were semantically related, since they all were parameters of the clustering algorithm, but in many other cases all the parameters aren't related. So, as we saw in our previous post for named parameters, we have to be careful of not accidentally sweeping hidden CoM in the form of data clumps under the rug when we use the Introduce Parameter Object refactoring.
In any case, what it's clear is that introducing a parameter object produces much less expressive code than introducing named parameters. So how to gain semantics while removing CoP in languages without named parameters?
This is just a simple test. However, just in this small piece of code, we can find two examples of removing CoP using fluent interfaces and another example that, while not removing CoP, completely removes its impact on expressiveness. Let's look at them with more detail.
Applying the builder pattern provides a very specific internal DSL that we can use to create a complex object avoiding CoP and also getting an expressiveness comparable or even superior to the one we'd get using named parameters.
In this case we composed two builders, one for the SafetyRange class:
and another for the Alarm class:
Composing builders you can manage to create very complex objects in a maintainable and very expressive way.
Let's see now the second interesting example in our small piece of code:
but for more than one parameter the JUnit interface starts having problems:
Which one is the expected value and which one is the actual one? We never manage to remember...
Using hamcrest removes that expressiveness problem:
Thanks to the semantics introduced by hamcrest, it's very clear that the first parameter is the actual value and the second parameter is the expected one. The internal DSL defined by hamcrest produces declarative code with high expressiveness. To be clear hamcrest is not removing the CoP, but since there are only two parameters, the degree of CoP is very low. The real problem of the code using the JUnit assertion was its low expressiveness and using hamcrest fixes that.
For us it's curious to see how, in trying to achieve expressiveness, some assertion libraries that use fluent interfaces have (probably not being aware of it) eliminate CoP as well. See this other example using Jasmine:
Finally, let's have a look at the last example in our initial small piece of code which is also using a fluent interface:
This is Mockito's way of defining a stub for a method call. It's another example of fluent interface which produces highly expressive code and avoids CoP.
We started seeing how, in languages that don't allow named parameters, we can remove CoP by applying the Introduce Parameter Object refactoring and how the resulting code was much less expressive than the one using the Introducing Named Parameters refactoring. Then we saw how we can leverage fluent interfaces to remove CoP while writing highly expressive code, mentioned internal DSLs and showed you how this technique is more common that one can think at first by examining a small piece of code.
 See Martin Fowler's Refactoring, Improving the Design of Existing Code book.
 Curiosly there're alternative ways to implement the builder pattern that use options maps or named parameters. Some time ago we wrote about an example of using the second way: Refactoring tests using builder functions in Clojure/ClojureScript.
 For us the best explanation of the builder pattern and how to use it to create maintanable tests is in chapter 22, Constructing Complex Test Data, of the wonderful Growing Object-Oriented Software Guided by Tests book.
 See our previous post about CoP.
- Refactoring: Improving the Design of Existing Code, Martin Fowler
- Growing Object-Oriented Software Guided by Tests, Nat Pryce and Steve Freeman.
- Refactoring Ruby, Jay Fields, Kent Beck, Martin Fowler, Shane Harvie
- Refactoring Ruby: Bad Smells in Code, Jay Fields, Kent Beck, Martin Fowler, Shane Harvie
- Builders vs option maps, Kyle Kingsbury
- Refactoring tests using builder functions in Clojure/ClojureScript, Manuel Rivero
- Remove data structures noise from your tests with builders, Carlos Blé
- Two examples of Connascence of Position, Manuel Rivero, Fran reyes
- About Connascence, Manuel Rivero