Top Signs of an Over-Experienced Programmer A response to the ex-Google Tech Lead

Photo by NESA by Makers on Unsplash
Software engineers seem to have a natural progression.

They go from inexperienced, to mid-level, to over-experienced engineers. Once

software engineers hit the over-experienced stage, they become less interested

in the code. Instead, they get distracted by design documents and refactoring

old code.

It is strange that most over-experienced engineers will exhibit the same set

of characteristics no matter what company you work for. Their lack of focus on

code slows down lines of code per engineer because more time is wasted

thinking through designs vs. just writing code.

This shift from a new engineer to over-experienced doesn’t happen overnight.

However, gradually over a few years or maybe even decades, these engineers

make a shift into the over-experienced category.

They seem to be the same in every single company and it’s just frustrating to

constantly deal with all their demands and unnecessary busy work.

If you’re a Jr. engineer or even an over-experienced engineer, this post will

help point out the traits you might be exhibiting that inhibit development.

They Waste Time Refactoring
In a recent Twitter post, the @rahulrana , arguably one of the most over-

experienced engineers currently alive, revealed his true thoughts about

writing code.

He clearly doesn’t believe in writing code. Instead, he seems to insinuate

that there is value in deleting and refactoring code.

But it’s not called software cleaning. It’s called software engineering.

That means you need to engineer code, not maintain it.

Maintaining code is someone else’s job. Maybe the intern can do it.

Software engineers should be spending their time coding around old inefficient

code rather than trying to improve old infrastructure. It’s OK to use duct

tape code as long as things work. Some future engineer will have to code

around our work. It’s not like we can do anything about it. Yet, over-

experienced engineers seem to believe that there is some importance in

maintaining old code.

They Want to Focus on the Big Picture Not the Code
Let’s be clear: the big picture and business side of things are not important,

only the code!

Over-experienced software engineers have a bad habit of focusing on the big

picture vs the code itself. They like to ask questions like “who will this

project impact”, “how will the end-user interact with the code”, and “how will

we maintain it?”

They waste a lot of time trying to understand the scope of the project and how

it will impact the company. Sometimes they will even challenge leadership with

what they believe are “superior solutions”. We are not even sure how they even

find time to finish all their coding when they are focused on such trivial

matters, like “impact” and “prioritization”.

Spending all that time in meetings, stand-ups, metrics tracking and on code-

reviews cause the purity of just writing code gets lost.

We are not surprised that over-experienced engineers sometimes lose that

glimmer of hope that exists in inexperienced engineers. Inexperienced

engineers focus only on the code and doing what they are told, even when the

scope might be overly complex.

This is because good programmers shouldn’t question what they are doing.

Instead, they should just put their heads down and code no matter the request.

The business knows exactly what will impact the company at all times. Our job

as programmers is to make it happen, not to figure out whether what we could

do is worth doing or how it fits into company strategy.

We need to help over-experienced engineers remember that they are programmers,

not leaders.

They Always Want a Design Doc
For some reason, over experienced software engineers always want a design

document.

It would be much faster to just start programming any project no matter the

size without thinking through a design document. It’s OK to skip through

thinking about what objects you need or what operational scenarios your code

will be put through.

From our perspective, we find it is much easier just to keep track of

everything in our heads. Even with thousands of lines of code, it’s not so

hard to manage.

It’s not like we would repeat functionality with a slightly different object

or anything.

We aren’t going to create duplicate functionality with multiple objects.

So why do over-experience software engineers care so much?

In the end, we would write code ten times faster and be able to provide impact

much more efficiently if we didn’t need to spend time thinking through a

design document.

They Dislike “Complexity” and “Over-Engineered Designs”

At a certain point, I think some engineers no longer want to think about other

people’s code.

So when you create a module that utilizes everything you learned at school all

in one amalgamation of object-oriented memoization, they like to claim that

the code is over-engineered.

Personally, we just think that they don’t want to think through the brilliance

of someone else’s masterpiece.

How hard would it be to take the time to understand the how object A inherits

from object B, which calls function C, which then calls function D and

sometimes options F or G that pulls in information from config file E, which

uses function F to parse data from database G that then stores logs in Hadoop,

CouchDB, and S3.

They start to complain and say that the code is too elegant and or over-

engineered. Their laziness keeps well-designed code that is really easy to

maintain out of production. Instead, they attempt to push younger engineers to

write code that is too simple.

Sure, it might seem like it’s easy to look at and understand. But as

engineers, we aren’t focused on simplification. We take complicated problems

and create complicated solutions.

They Are Stuck in the Future
The frameworks I know now are the only frameworks I will need to know from now

until I die.

Yet, over-experienced engineers seem to spend a lot of time learning new

frameworks and languages or at the very least, reading up on new design

principles.

It all seems like a waste of time. As an engineer, you should be smart enough

to know everything you need to know after you finish college. Anything after

the fact is clearly not important. Some of them even still practice leet code

problems and study, as if they might have an interview coming up. It’s not

like software engineers have to worry about being let go.

Doesn’t everyone still program in the language they learned in college?

Over-experienced software engineers hold society back.

With their constant need for code-refactoring, design documents and learning

they keep major software advancements from moving forward. We’re pretty sure

we would already have flying cars and robots that are smarter than us right

now if it wasn’t for over-experienced engineers. Instead, we’re stuck with

280-character Tweets and Amazon ads that keep trying to sell me the same

toilet seat cover I bought last week.