5 workflow hacks every developer needs
Building better software and products should be the focus of every modern company. But most organizations struggle with challenges that keep their team from doing their best work — from contending with an overload of toil to a lack of cross-team collaboration. How do we ensure our developers are engaged, challenged, and moving forward in their work? We’ll look at 5 key developer workflow hacks to keep your team not just on track, but surging forward.
1. Cut down on your meeting load to find your creative flow
Some people refer to it as being “in the zone”; others refer to it as “creative flow,” However you name it, the state of being fully immersed in a task is just as essential for developers and software engineers as it is for artists and creative professionals. Flow state is characterized by deep absorption, a loss of self-consciousness, and intrinsic satisfaction in the task at hand. When you’re in the flow state, you lose track of time passing and forget about more practical concerns.
Coding is highly cerebral and abstract, and developers need long stretches of non-interrupted time to develop well. Too many meetings can turn a potentially productive day into a development loss. Similarly, an environment full of distractions can have the same effect. Try to reduce extraneous meetings and distractions to give yourself extended chunks of time to code.
2. Diversify and deepen your knowledge
Rarely does any finished piece of software rely on one technology for completion from front end to back end. Knowing more languages helps solve problems and gives you more alternatives when tackling a project.
3. Try letting tests drive your next project
Although Test-Driven Development (TDD) may not always be the path of least resistance on paper, it teaches developers to code for edge cases and makes them better programmers by playing the role of end user. In TDD, developers create tests that target the functionality of specific features.
The first step of TDD is generally to devise a use case for the part of software you are building, putting yourself in the shoes of an actor using the system, and thinking carefully about the steps an actor must take to achieve the desired outcome. Write a unit test to cover a small portion of logic. Second, run a unit test before you have written any code — and watch it fail. This may seem counterintuitive, but if the test doesn’t fail, you may be duplicating existing code. Third, write your functional code to fill the requirement and pass the test. Keep tweaking the code until it passes the test; once the test passes, begin the cycle all over again.
Writing tests encourages developers to articulate exactly what they want from the code and the functions that it will provide. Many developers shy away from TDD due to the time involved, but the code produced through TDD is ultimately cleaner and more fault-tolerant in the long run.
4. Find a buddy and start pair coding
The old adage “two heads are better than one” holds true after all. Working with a buddy might seem inefficient, but having a partner can improve productivity. Forget one colon or function definition? A partner can spot errors that cost time and money, and perform research when a quick answer is needed. Talking through your thought process out loud can also be helpful for getting over roadblocks. When forced to verbalize your ideas, you might become aware of logical flaws – or shortcuts to a pesky problem.
Remember those skill sets you fostered in workflow hack #2? Working with a partner lets you both tap into a broader range of experiences and skills than either of you have on your own. You’ll be able to go faster and farther together than you will alone.
As an added perk, pair programming improves overall team productivity by encouraging colleagues to think in the same patterns, share ideas more freely, and collaborate more regularly.
5. Break big projects into little projects
Given how cerebral development work is, it’s difficult to hold and imagine large tasks in your head. The harder things are to imagine, the slower they are to be built. Developers move faster when the goal is small and concise. Rather than juggling all the attributes of the final application, define the functions and attributes of each tiny component. Keep scaling down until it’s manageable. For instance, coding a chess game might seem like an overwhelming task – but if you divide a chess game down into its fundamental components and begin by asking, “What is a pawn? What are the functions of a pawn?”, you have a more manageable task.
Another way of thinking about this is to define “What I have” and think about “What I want”. Keep dividing the “What I want” into smaller and smaller pieces, and you’ll end up with a bunch of verbs on the page. Connect the verbs with arrows from one to the next. Those verbs become your functions, and if you have broken things down into small enough pieces, the implementation will be much less painful.
Need a bigger workflow hack? Learn more about improving developer productivity
These workflow hacks can help you shake things up and get your team coding and collaborating more effectively. But if you find that your team is still struggling to move as quickly and as productively as they’d like to, it might be time for a more strategic approach. Check out Unblocking Workflows: The Guide to Developer Productivity to learn how developer teams can break through the biggest productivities and start collaborating better today.