Pathologies of Redundant Code

July 19, 2017 0 comments

Remember Y2K? Before the turn of the millennium, computer storage was at such a premium that years were stored with only the last two digits so the year 1989 was stored as 89. This worked fine—up until the end of 1999, at which point the year returns to 00 which many programs would interpret as […]

CONTINUE READING THIS POST →

Quality Code is Nonredundant

July 12, 2017 0 comments

The last code quality that we’ll discuss in this series, the “N” in CLEAN, calls for code to be nonredundant. On its surface it seems pretty straightforward but there is some subtlety to redundancy as well. It’s easy to see why redundancy in code is a bad thing. It’s a duplicated effort. It means that […]

CONTINUE READING THIS POST →

Assertiveness and Testability

July 5, 2017 0 comments

It’s quite difficult to test inquisitive code. Very often the results of running a piece of code can only be found in another object. Therefore a test must use a separate entity, which we typically call a “spy,” to monitor the external object and validate that it was called correctly. This adds unnecessary complexity to […]

CONTINUE READING THIS POST →

Pathologies of Inquisitive Code

June 28, 2017 0 comments

Objects that are not assertive are by default inquisitive. They are either inquisitive or they are mute. They don’t interact with the outside word at all. If an object interacts with other objects, the real question with regard to assertiveness is, “Who’s in charge?” One object can delegate a task to another object but still […]

CONTINUE READING THIS POST →

Quality Code is Assertive

June 21, 2017 0 comments

The next code quality in this series of posts, the “A” in CLEAN, stands for assertive. I don’t hear a lot of people talking about it but I think it’s an important code quality. We want the software we write to be assertive, to be in charge of its own state. We want objects to […]

CONTINUE READING THIS POST →

Encapsulation and Testability

June 14, 2017 0 comments

Poorly encapsulated software is hard to test because without clear boundaries, what we actually test becomes significantly larger than what we need to test. This makes our tests run slower and it also makes them brittle so our tests are harder to maintain. When code is unencapsulated, it can be hard to lock down behaviors […]

CONTINUE READING THIS POST →

Pathologies of Unencapsulated Code

June 7, 2017 0 comments

Unencapsulated code is code that exposes its implementation or references how it does something. This can happen in subtle ways, so we have to be careful to create strong contracts through our method signatures. Poorly encapsulated code is very difficult to work with. It can quickly sprout new bugs at the slightest change. Lack of […]

CONTINUE READING THIS POST →

Quality Code is Encapsulated

May 31, 2017 0 comments

To encapsulate something is to envelope and protect it. Encapsulation is a fundamental facility that every programming language supports at some level. Encapsulation is about hiding implementation details so ideas can be expressed at higher levels and to protect those details from other parts of the system. To me, most fundamentally, encapsulation means hiding implementation […]

CONTINUE READING THIS POST →

Coupling and Testability

May 24, 2017 3 comments

I can learn a lot about the kind of coupling in a system by listening to how people talk about testing it. If someone says, “I couldn’t test that without instantiating half the system,” then I know they have some coupling issues. Unfortunately, most systems I have seen—and most systems I know other people have […]

CONTINUE READING THIS POST →

Pathologies of Tight Coupling

May 17, 2017 0 comments

We continue our conversation on code qualities with a discussion of why tight coupling is undesirable. Again, I want to stress, as I did in the last post, that we’re not striving for no coupling in a system. A system with no coupling is a system that does nothing. We want the right kind of […]

CONTINUE READING THIS POST →

Quality Code is Loosely Coupled

May 10, 2017 2 comments

While cohesion, which was the subject of the last three posts, is about the internal consistency of a class or method, coupling is a code quality that looks at the relationship between entities. There are two distinct forms of coupling: loose coupling and tight coupling. One is good, the other isn’t—and I always forget which […]

CONTINUE READING THIS POST →

Cohesion and Testability

May 3, 2017 0 comments

I feel like I try to go around and get developers to do little things that will make a big difference in their work. For example, if you need to add some behavior to your system, rather than putting that behavior into some pre-existing entity, you should probably create a new class for that new […]

CONTINUE READING THIS POST →

Pathologies of Uncohesive Code

April 26, 2017 0 comments

Uncohesive code is code that either has too many responsibilities or has poorly defined responsibilities. Typically, it’s code that tries to do too much. Poorly cohesive classes are difficult to understand and maintain. They’re harder to debug and more difficult to extend. The bottom line is the more issues a class has to deal with, […]

CONTINUE READING THIS POST →

Quality Code is Cohesive

April 19, 2017 2 comments

The first code quality we’ll discuss is my very favorite: cohesion. Cohesive code is highly focused code that’s straightforward and easy to read. I like cohesion because it’s the easiest one for me to spot, but I recognize that that’s not true for everyone. People have told me that cohesion is actually the hardest for […]

CONTINUE READING THIS POST →