Most of us developers think we're smart. But we aren't smart. We're clever.

And confused.

You can easily prove this by looking at our code. Specifically, by answering these questions:

1. How many layers of indirection are there?
2. How many abstractions of abstractions are there?
3. How many different things are our methods doing?

Combined, these reveal how complicated a set of code is.

What we do as developers is complex. There are lots of little moving parts that all need to work together.

Complex: composed of many interconnected parts; compound; composite¹

Complicated: difficult to analyze, understand, explain, etc.²

Because we're clever, we think we understand how to manage this complexity. But we don't. We're confused by it. So, instead of making the complex clear, we complicate it. We add stuff that makes those moving parts harder to understand (over-use of indirection and abstraction), and harder to work together (method multi-responsibility).

No one likes to hear this or face it in themselves. But we face it too often when supporting others' code. It comes with that little, internal question, "Couldn't this be easier?"

So, what do we do?

First, decide that "we" applies to "you." It's better to start with this assumption because it leads to learning rather than avoidance. If I insist I'm smart, I won't make the effort to learn better--thus, not smart. But if I insist I can be better, no matter how good I am, then the path to improvement and away from stagnation opens long and wide.

Second, find examples of complex code that isn't complicated. Open source projects coming out of Microsoft and Google are good starting points.

Third, Read about and apply the principles behind uncomplicating code. Three of these are:

1. SOLID
2. DRY
3. YAGNI

Finally, be guided by four overarching principles in your architecture and coding. Make your code...

1. Clear
2. Secure
3. Maintainable
4. Testable

We may not be smart, but be can code smarter.