Pairing and Collective Code Ownership

September 20, 2017 0 comments

I’ve been writing a lot recently on pair programming and mob programming and I’ve been syndicating my posts at Dzone.com, which is a web portal for software developers. I’ve received some scathing comments about pairing and mobbing from people who’ve obviously never tried it. If something doesn’t work for you then by all means abandon […]

CONTINUE READING THIS POST →

Collective Code Ownership

September 13, 2017 0 comments

Like many artists I used to sign my work. When I wrote a class or a module, I put my initials in a comment that indicated I was the developer who wrote that code. This was a common practice at virtually everywhere I worked from IBM to small shops that developed financial or banking software. […]

CONTINUE READING THIS POST →

Forget About Velocity

September 6, 2017 0 comments

I wrote about increasing velocity in my last post, but I just can’t let it be. I have to tell you about the dark side of velocity and why I don’t recommend that teams track velocity. Velocity is the amount of work a team can accomplish in a fixed period of time. It’s used to […]

CONTINUE READING THIS POST →

How to Increase Velocity

August 30, 2017 0 comments

Do you want to know a trick to increase your team’s velocity? Now that I have your attention I want to tell you that tricks don’t work. I’ve seen people play tricks and sacrifice quality in order to get something out only to regret it later. So here’s my non-trick trick: Increase code quality today […]

CONTINUE READING THIS POST →

Testability Affects Code Quality

August 23, 2017 0 comments

Why is it that if we all agree that CLEAN code is good to strive for that the vast majority of software as written lacks these qualities? The only answer I can come up with is that we’re so focused on short-term gains that we forget about the long-term consequences. I have to point out […]

CONTINUE READING THIS POST →

Let Testability Guide You

August 16, 2017 0 comments

In my last blog post, Let Code Quality Guide You, I said you don’t have to focus on all five CLEAN code qualities and that if you improve one, it’s typical that the others improve as well because they’re all interrelated. And that’s true, but they’re interrelated at a higher level, which points to a […]

CONTINUE READING THIS POST →

Let Code Quality Guide You

August 9, 2017 2 comments

Back in the 1990s when I was faced with multiple design choices, I’d have to code them up in multiple ways in order to figure out which one was best. This was time consuming, and evaluating design choices was one of the hardest things for me. But now I have a better approach, thanks to […]

CONTINUE READING THIS POST →

What I Mean by CLEAN

August 2, 2017 0 comments

If you’re reading my blog posts as they come out then you already know about CLEAN, which is my acronym for five code qualities that improve the testability and maintainability of software. If you’re reading these posts as archives in reverse chronological order, then the acronym is: NAELC. It’s unpronounceable, but it still contains goodness. […]

CONTINUE READING THIS POST →

Nonredundancy and Testability

July 26, 2017 0 comments

Redundancy is always a maintenance issue. If you have to change redundant code, you have to do it in multiple places. If you have to extend redundant code, you have to do it in multiple places. When you have to test redundant code, you have to modify tests in multiple places. You get the idea. […]

CONTINUE READING THIS POST →

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 →