Development Time Dependency

When one class cannot be compiled without another, we call that a Compile Time Dependency. When an object uses another in a running system, we call that a Runtime Dependency.

I was looking for a way to explain the benefits of respecting the Law of Demeter, and ran into a snag because doing so does not necessarily reduce Compile Time or even Runtime dependencies. Take for example the following:

To get and set pieces on the board, the client code looks like this:

board.getSquareAt(0,0).setPiece(piece);
board.getSquareAt(0,0).getPiece();

Client depends on Square even though Client is only interested in the Board and Pieces. That dependency is a violation of the Law of Demeter, often manifested in the form of message chains like those above. In order to address that violation, you might move to a structure like this...

...which allows for client code like this:

board.setPiece(piece, 0, 0);
board.getPieceAt(0,0);

This does clean up the code in Client, but it doesn't really reduce any Compile Time or Runtime Dependencies. Compile Time Dependencies are transitive. Because Client depends on Board and Board depends on Square, Client still depends on Square even though there is no direct reference to Square in Client. Similarly, even though Client never uses Square directly, we still need on at run time in order to exercise these operations.

It also costs us an additional method on Board.

So what benefit are we reaping by doing this? There's an added method and no reduction in compile time or runtime dependencies.

Well, the benefit is that we are now free to change the internal structure of Board without having to change any of the code in Client. We can store Squares in Rows and Columns, or even get rid of them entirely, and the changes would not ripple out to our Client. Sure we have to recompile Client, but we live in a day and age in which we encourage recompiling on every commit to our source repository! So unless you're dealing with a tangled mess o' legacy, that's probably not a big problem.

I think we need a name for this other kind of dependency. The one that gets reduced when we remove message chains. The one that is not revealed at compile time or run time, but rather when making changes to the software.

I'd like to call it "Development Time Dependency".

What do YOU think?

---

!commentForm