TL;DR: Long chains of collaborations generate coupling and ripple effect, where any change in the chain breaks the code.

Problems

• Coupling

• Break encapsulation

Solutions

• Create intermediate methods.

• Consider the Law of Demeter.

• Create higher-level messages.

Sample Code

Wrong

class Dog(val feet: Array<Foot>) {
}

class Foot {
    fun move(): Unit = TODO()
}

fun main() {
    val feet = arrayOf(Foot(), Foot(), Foot(), Foot())
    val dog = Dog(feet)

    for(foot in dog.feet) {
        foot.move()
    }
}

Right

// We're copying the reference of the array, so in theory, it can still
// be changed from outside, which is yet another code smell. A better
// approach would be to create a copy of the array inside the class
// instead of holding the reference.
class Dog(private val feet: Array<Foot>) {
    fun walk() {
        for(foot in feet) {
            foot.move()
        }
    }
}

class Foot {
    fun move(): Unit = TODO()
}

fun main() {
    val feet = arrayOf(Foot(), Foot(), Foot(), Foot())
    val dog = Dog(feet)
    dog.walk()
}

Conclusion

Avoid successive message calls. Try to hide the intermediate collaborations and create new protocols. This way, not only will you protect your code from breaking in the future, but you will also maintain good encapsulation of your class.

More Info

• Refactoring Guru

Credits

• Code Smell 08 - Long Chains Of Collaborations by Maximiliano Contieri