There and Back Again: A Lead Developer’s Tale

“It’s not at all important to get it right the first time. It’s vitally important to get it right the last time.” – Andy Hunt & Dave Thomas

This pragmatic quote rings true in much of what we do here as an agency. In particular, it applies to development, which has a major role in Noble Studios’ think-make-measure model. Whether it’s showing the value, acquiring leads, or being first to market, the adage is relevant.

At Noble Studios, we have grown our development team into a sizable force for completing many things in parallel. This stalwart squad of hackers requires a different approach when it comes to leadership. They are quick to call out falsehoods, repeated mistakes, “fluff” and other things they may consider to be inefficiencies. Getting the team up to a scalable model, although not quite arduous, has proven to be a longer learning process than one might think.

After all, what more is there than to have your team program in the same language and re-use code? All developers should aspire to be at the same skill level, right? They graduate from college and they are ready to go? Myth busted.

  • Most projects involve at least four different languages which have numerous differences in styles. Each of those languages has their own standards.
  • Just about every site we build has to be unique in many ways. Some code can be leveraged, some has to be custom tailored.
  • College students, at the moment, are not web ready. They are software ready. A completely different ball game.

One thing I’ve explained several times throughout my career is: “Anyone can learn to code in a day or two. Learning how to not code, that’s what takes years.”

There are many ways to make something work in the tech world. With each solution, there are a slew of reasons not to use the ones that may first come to mind. Is it cross browser compatible? What about other platforms? How easy is this to change or replicate later? What if we want to use it in tandem with other things later? The list goes on.

Some developers will take the first step forward and worry about the consequences later; this is great as it keeps momentum going. But with momentum, comes technical debt. Technical debt is the rot of development teams. It’s one of the key things a strong leader needs to recognize when leading a development team.

You can worry about process, standards, morale, efficiency or whatever — but in the end, if you don’t tackle the debt or the rot, you will fail eventually.

In construction, it is common to say, without a good foundation, the building will not last. The same is true with technical teams. Here is a list of some of the things we have done to cut away some of the rot:

  • Distributed version control system
  • Coding standard, beyond what the industry demands
  • Staged deployments
  • Inventory of our current technology portfolio
  • Analyzed our current portfolio, and then made systematic moves towards more stable solutions
  • Created a way to share knowledge within our department as well as externally
  • Began internal side projects which benefit the team and the company
  • Adopted theories such as the broken windows theory and how it relates to software entropy

Since we have refined our development process, our productivity is up. We are also more proactive and solve problems more efficiently.