As software developers, we are always looking for ways to improve our everyday work, make our lives easier and provide good value for the companies that we are working with. It’s important as developers that we continue to look ahead and solve problems today so that we are not fixing the same bugs tomorrow.
There are at least four software characteristics where we provide value: functionality, security, performance, and efficiency. And with a simple strategy, we can actually address all four characteristics.
First, a few definitions:
Functionality refers to the software performing what is intended without bugs.
Security is ensuring the protection of data. Software developers must make sure that sensitive data is not at risk of exposure or violation.
Performance refers to the software performing its functionality within a time specification. Examples include UX or API latency, page load speed, transactions per second, requests per second, etc. When delivering a high quality software, one would consider that performance in the process.
Finally, and most importantly, efficiency. For this we are referring to saving time and money in the long run. As an efficient dev, we are going to save companies money by delivering high quality software faster, with less maintenance or bugs fixing.
If we can achieve all four of these, we will ensure that the other members of the company trust the development team.
What magic can achieve that?
The magic lies in two powerful techniques: Divide and Conquer Work and Pair Work — two techniques for splitting implementation and testing.
Consider the following example: Lets pick two developers and decide the role of each one then parallelize the implementation and testing.
Developer 1: Works on functionality and performance
Developer 2: Works on creating the tests and focuses on security.
Developer 1 & 2: Do code review
Working in parallel would definitely speed up the delivery.
Since the developer that is working on the tests doesn’t know the details of the implementation, they can think of covering all the possible scenarios. Then, when they connect the tests and the implementation, the developers can feel confident in their software’s security and code quality, thus improving the team’s long term efficiency.
This process can be done with the benefits of gamification.
Since each developer has a role they can “play” trying to find something that the other dev didn’t cover. With this approach that team should be highly motivated, committed to their role, and dedicated to applying best practices.
As a bonus, but no less important, the developers are generating new communication lines within the team, they are transferring knowledge among themselves and creating synergy that achieves results that are higher than expected.