Coding Super-Complexity

Young, intelligent developers often fail when they become accustomed to the following two things:

• being 10x smarter than everyone around them; and
• fitting all the code in their head 

When they join a team where everyone else is pretty smart - even if not quite as smart - they can still fail hard.

They are like younger, stronger kung-fu warriors that yet cannot best the wizened master!

The problem is that while they may be able to solve problems that are 10x more complex than other developers, this is only true when limited to a practice which requires one to remember and understand everything about the system under development. Note that this is typical experience in hobby projects and many university projects.

I think software engineering, definitively, focuses on solving problems which require software to be built that is generally much larger than anyone can fit in their head. 

In some ways intelligence can be a curse because it delays the lesson that systemic practices and superior tools (languages, architecture, frameworks) are necessary. Here I identify tools and techniques as superior primarily by their ability to massively magnify the effectiveness of our ability to deal with complexity. To tame it. To contain it.

Isolation, abstraction, automation - these things all help pump complexity out of the brain and into the software. It's true these systems can fail. Machines can fail and all software has bugs. But it's also true that we can often rely on them and that refusing to rely on them is a severe limitation and in some people who never learn this, even a personality defect!