Rot

Photo by WillSculling

I’m quite fascinated by how quickly code rots and becomes a mess,
despite the programmers best intentions. A lot could be fixed by testing
and and refactoring more often, but it always seems to come second to
getting shit done, and does sometimes have unintended effects.

For some reason I see this more often in Java code than in other
languages. Maybe it’s because of its class-madness creating deep nested
code (try to trace a call through Jersey, I dare you.).

Jersey is actually a nice example of this. The code is in itself clean,
documented and well tested, but it is still (in my opinion) a mess.
Seems to me that abstraction does not only have an performance penalty,
but a readability issue as well. And in this case, it seems the code has
been tested and refactored multiple times, but still it’s hard to
understand.

Seems like there is a fine line between reusability and loss of
understanding for what happens inside the black box.

Photo by Will
Sculling