Desk Checking: How it can be useful for testers

Desk checking is an essential technique in software development and testing that involves a thorough manual review of source code. It is one of the first lines of defense against bugs and errors, providing a unique opportunity for developers and testers to understand and verify code before it proceeds to more formal testing phases. This technique not only aids in detecting errors but also enhances the overall quality and reliability of the software product.

What is Desk Checking in software testing?

In the realm of software testing, desk checking is considered a static testing method where code is analyzed manually without executing it. The process involves a developer or a tester going through the code line by line to check for logical errors, syntax inconsistencies, and compliance with coding standards and requirements. This method can be conducted by the coder who wrote the software, a peer, or a testing professional, often involving discussions or sessions where the logic and approach of the code are debated and scrutinized.

Advantages of Desk Checking

Desk checking offers multiple advantages that make it an invaluable tool in the software development lifecycle:

1. Early Error Detection: By identifying errors at an early stage, desk checking helps in mitigating the costs associated with later stages of testing and maintenance.
2. Improved Code Quality: As errors are detected and fixed early, the overall quality of the code improves, leading to more stable and reliable software.
3. Enhanced Understanding: This technique provides testers and developers with a deeper understanding of the code’s functionality and logic, which is crucial for effective testing and maintenance.
4. Cost–Effective: It is a cost-effective method of testing as it does not require any additional tools or software and can significantly reduce the future costs of debugging and development.
5. Facilitates Collaboration: Desk checking often involves multiple members of the development team, fostering better communication and collaboration, and shared understanding of the project goals and methodologies.

Best Practices in Desk Checking

To maximize the effectiveness of desk checking, consider the following best practices:

1. Include Diverse Team Members: Engage individuals from different backgrounds such as development, testing, and design to provide multiple perspectives.
2. Prepare and Plan: Ensure that the code is well-documented and that all necessary materials (such as requirements, design documents, and coding standards) are available before the session.
3. Use Checklists: Develop checklists based on common error patterns in previous projects to ensure that critical aspects are not overlooked.
4. Record Findings: Document all observations and decisions made during the desk check for future reference and action.
5. Follow Up: It’s essential to address the findings from desk checking promptly. Plan follow-up sessions if needed to verify that corrections are properly implemented.

While conducting desk checks, there are certain pitfalls that need to be avoided:

1. Overlooking Complexity: Complex pieces of code should be given extra attention and might require more time or a different approach to thoroughly understand and check.
2. Bias: There can be a tendency to overlook errors in one’s own code or to not critique a peer’s code thoroughly. An unbiased approach is critical.
3. Inadequate Preparation: Without proper preparation, desk checking sessions can be less productive. Participants should be well-prepared with a good understanding of the code and related documents.
4. Lack of Engagement: All participants should be actively involved in the process to provide insights and identify potential issues.

Use Case: Desk Checking for an E-commerce Application

Scenario:

An e-commerce company is developing a new feature for their online shopping platform that allows users to apply multiple discount codes at checkout. The development team has just completed the initial coding phase of this feature.

Steps:

• Preparation: 
  • Developer prepares the code and documentation, including the logic flow and any assumptions made during development. 
  • A meeting is called to conduct the desk check.
• Initial Review:
  • Developer presents the code, explaining the logic they implemented to handle multiple discount codes and how they interact with existing features like promotional discounts and loyalty points.
  • QA engineer reviews the code line by line, checking for logical consistency and adherence to the requirements specified in the design document.
• Identification of Issues:
  • QA engineer identifies a section of the code that could lead to a race condition where two discounts are applied simultaneously in a way that exceeds the total cart value.
  • BA’s acknowledge the oversight and discuss possible solutions with developers.
• Resolution and Action Items:
  • The team agrees on a strategy to modify the code to handle exceptions more gracefully, including adding additional checks for discount combinations that are not allowed.
  • Developer takes notes on all feedback and agrees to revise the code accordingly. They schedule a follow-up session for the team to review the changes.
• Documentation and Follow-up:
  • QA engineer documents the findings and the agreed-upon action items in the project’s issue tracking system.
  • Project manager updates the project timeline to include additional time for re-testing the updated feature.
• Code Revision and Re-check:
  • Developer revises the code, incorporating all feedback. Once the updates are made, he invites the team for a second desk check.
  • The team reviews the revised code, confirming that all previously identified issues have been resolved effectively.
• Final Approval and Move to Testing:
  • QA engineer prepares to conduct formal testing, including both automated and manual test cases, to ensure the feature works as expected under various scenarios.

Conclusion

Desk checking is a fundamental practice in the testing strategy of any software development project. It not only helps in identifying and fixing errors early but also promotes a deeper understanding of the code among team members. By adhering to best practices and being mindful of common pitfalls, teams can effectively leverage desk checking to enhance software quality and reduce development time and costs. As technology evolves, the principles of desk checking remain relevant, underscoring its importance in achieving high-quality software products.