6 Truths About Rockstar Developers

By September 25, 2012 Guest Post 5 Comments
Share on FacebookShare on Google+Tweet about this on TwitterShare on LinkedInEmail this to someone

This great post was originally published over at InfoWorld. Andrew Oliver tells it how it is, and it gets a little funny along the way.

In praise of software developers who actually get the job done

A big, important project has launched — and abruptly crashed to the ground. The horrible spaghetti code is beyond debugging. There are no unit tests, and every change requires a meeting with, like, 40 people.

Oh, if only we’d had a team of 10 “rock star” developers working on this project instead! It would have been done in half the time with twice the features and five-nines availability.

On the other hand, maybe not. A team of senior developers will often produce a complex design and no code, thanks to the reasons listed below.

Truth no. 1: You can’t afford all senior developers
Many managers have an unrealistic understanding of the labor market for software developers. Just get 10 extremely senior developers to work on an application, and presto, success! These same managers also generally believe they can hire senior developers for less than the market demands; for example, $100,000 isn’t enough for your senior-most position in most areas of the country. Best case, you’ll get one or two senior developers and eight or nine liars.

Truth no. 2: People do their best work when their head is barely above water
When you have a senior developer typewriting JSP pages (read: ASP, PHP, whatever), that person won’t actually perform as good a job as a more junior-level developer who hasn’t slogged through it 100 times before. A senior developer, even one with good intentions, will phone it in after the first few weeks because he or she is inescapably bored. A junior developer assigned to the same job will work a lot harder.

Truth no. 3: Too many senior developers spoil the code
If I were working alongside a bunch of other senior developers on a simple project like the one mentioned above, out of boredom we would come up with a way not to use JSP pages at all. Instead, we’d engineer the most powerful and flexible templating system that was not JSP ever designed.

There would be extensive discussions and architecture meetings. A pretty basic B2B website would become one of the most complex architectures ever created. Why? Because we can. We’re smart. We can keep up. We’d definitely do an entirely functional programming design because this is our chance to show our friends it can be done.

Ultimately, we’d run overtime and request “interns or something” because a few “little things” and “bug hunting” still need to be done. After a time, a handful of bright interns would end up doing most of the actual work on the project, while us senior developers exercised our whiteboard brilliance.

Sound far-fetched? I saw it happen on a multi-million-dollar corporate website project that lasted over a year. Not long before, I had led a more complex B2B portal project with a small team of four more junior people — and delivered in about three months. No one ever compared the ROI between the two projects.

Truth no. 4: Most senior developers are not senior
While conducting interviews, my company has encountered at least a dozen strong lead developers who didn’t actually know how to code. Most developers overrate themselves and align their title with their salary expectations. Knowing how to talk about monads and Hadoop doesn’t actually mean you know how and when to use them or, more importantly, when not to. It doesn’t even mean you know how to write a simple SQL statement.

Our interview process involves a coding test. It has the world’s simplest requirements: “Granny’s address book.”

Senior developers need to be able to read requirements and create reasonable code that someone can follow. They need to be able to write simple instructions on how to install and deploy the software. Most people we interview write code that throws an exception on startup and instructions that are wrong at best and poorly written and indecipherable at worst.

Truth no. 5: Arrogance goes before the fall
I’ve seen projects that were extremely sophisticated fall down in production due to very basic oversights. Generally, these were the result of smart people who wrote really “smart” code but who, like the engineers of the Titanic, thought their creation was unsinkable and neglected to try and prove otherwise.

Overconfidence is a dominant personality trait in the developer community, and it doesn’t seem to abate with experience. With senior developers, having other people tell you how smart you are can make a bad personality trait worse. We think we can handle the complexity, so we create it. Unproven technology can’t come back to bite the likes of us! We don’t need to test this one section of code thoroughly. We know it works — because we wrote it!

Talk is cheap. Results speak for themselves — and both method and materials selected by careful judgement bring results. The scientific method requires us to prove what we know. Arrogance and overconfidence cause us to believe things without proof.

Truth no. 6: Individuals aren’t the be-all and end-all
Projects are created by groups of people. Groups are organic and dynamic. Interactions inside groups are just as important as the individuals that make it up. The best groups are ones that force members to grow. Developers tend to be incredibly individualistic and always feel underappreciated.

Nonetheless, few learned everything on their own; they benefited from other developers showing them the tricks of the trade. Whether these were formal or informal mentors, they were critical in any long career. Creating a teaching environment is the most important thing a manager or lead can do. This lets you grow your own senior developers.

Senior developers need constraints. Time and budget are obvious — but to some hotshots, they’re also elastic, as complexity gets piled on complexity. When junior developers are also on the team, their ability to keep up with the high-falutin’ stuff will be limited. That’s a good thing, because it encourages simplicity, which is usually your friend.

A mixed team aligns the company’s interest with the developers’ interests. A mixed team provides a good career opportunity for all: leadership experience for senior developers and a chance for junior developers to learn new things.

What do you think? Let us know in comments!

Share on FacebookShare on Google+Tweet about this on TwitterShare on LinkedInEmail this to someone

5 Comments

  • […] 6 Truths About Rockstar Developers (Jelastic — Rock-Solid Java in the Cloud, Java Server Hosting, Java Cloud Computing) […]

  • Peter Sramka says:

    A truely smart senior developer would always make the design and code as simple and unoriginal as possible. Alas, such senior developers are rare indeed!

    “A good engineer is a person who makes a design that works with as few original ideas as possible.” — Freeman Dyson, theoretical physicist and mathematician

  • […] 6 Truths About Rockstar Developers (jelastic.com) […]

  • engineer says:

    Unit tests are a sign of low quality developers. You use unit tests to catch when developers don’t know what they’re doing. So, a good way to screen for quality developers (of all experience levels) is to ask them when they will use unit tests. IF they say “always” or “never” they’re not high quality (or experienced enough). The right time to use unit tests is when creating an API or other interface that needs to not change.

    There’s a weird tendency to claim that you want to hire “the best” yet these same companies put in procedures and methodologies that assume their developers suck. They also will hire cheap because they are cheap or don’t know how to tell a good developer from a bad one.

    But then, any company with an open floor plan obviously doesn’t treat developers well (Same with pair programming and SCRUM and other cargo-cult procedural crap.)

Leave a Reply

Subscribe to get the latest updates