Developers are the engine of software development, the people who write the code. Empowering developers to improve and supporting them to do the right things is an important part of building great software. Here are seven strategies for empowering developers.
1. Avoid sacrificing quality
Unrealistic deadlines can lead to cutting corners that shouldn’t be cut. In my experience, most developers aren’t striving for perfect code but they do want what they write to be robust enough to hold up in production. Understanding tradeoffs from a technical, risk, and value perspective is important for making the best decisions. It is usually better to cut scope than to cut quality since you can always add scope later but when quality is missing you can end up with a mess.
2. Agree on how to report progress
There’s value in frequently checking in, noticing progress, and re-estimating tasks–it helps us see when we are not making progress so we can stay more productive. Daily updates in a stand-up meeting or on a wiki are good ways to check in without requiring a lot of time and effort.
3. Encourage collaboration
Disseminating knowledge of standards and practices across a team is highly valuable. Encourage team members to work together on tasks including pair programming, code reviews, planning, designing, debugging, etc. Encourage people to pair with as many other people as possible so everyone at least knows what it is like to work directly with everyone else. Then give people latitude to collaborate with who they want.
4. Respect each other
Respect is a key ingredient in any relationship. Developers often have vastly different backgrounds and therefore their orientations may be different as well. It takes many different kinds of Intelligences to write software and there is value for the team in having different skill-sets. Acknowledge what others do well and encourage them to contribute their skills. The more we can support what others enjoy doing, the more they will bring their best to their work.
5. Ask for recommendations
Developers are the experts on the code they wrote. They know what it can do and what it can’t. Implementing a new feature involves creating the feature and integrating it into the existing system. Depending on the situation new features may be easy or difficult to add. It is not uncommon for tasks that seem easy to actually be difficult and for tasks that seem difficult to actually be easy so ask for recommendations and look for alternatives.
6. Focus on goals and constraints
By focusing on what you want and why you want it with developers they are free to discover how to best implement it. We don’t have to have all the answers up front and developers can often discover more flexible and supportable implementations as they are developing. Provide consistent metaphors and use the domain language but let the developers emerge the design as they go.
7. Acknowledge contribution
Software development is a team effort and we all bring something unique to the mix. Everyone wants to be acknowledged for their contribution and doing this encourages greater contributions in the future.
People want to do their best and if they are not giving their best consistently it usually is because they feel it won’t make a difference. Demonstrate that their efforts are important and you will have more committed team members. Software developer productivity can be greatly increased and we are far more capable than we know ourselves to be. Helping unlock the potential in ourselves and others can be one of the most rewarding things we can do.