The title of the post can indeed be a big debate. If Developers are testing their own code – what will be the testing output? All happy endings! Yes, the person who develops the code generally sees only Happy Paths of the product and doesn’t want to go into much detail.
The main concern with Developer Testing is – misunderstanding of requirements. If the requirements are misunderstood by the developer then no matter at what depth the developer tests the application, he will never find the error.
The first place where the bug gets introduced will remain till the end, as a developer will see it as the functionality.
Optimistic Developers – Yes, I wrote the code and I am confident it’s working properly. There is no need to test any path, as I know it’s working properly. This is where the developers skip the Bugs.
Developer vs Tester: Developer always wants to see his code working properly. Thus, he will test it to check if it’s working correctly. But do you know why the tester will test the application? To make it fail in any way, and the tester will surely test how an application is not working correctly. This is the main difference between Developer Testing and Tester Testing.
Should Developers Test Their Own Work?
I personally don’t mind developers testing their own code. After all, it’s their baby :-) They know their code much better than others. They know what the traps are in their codes.
Where it can fail, where to concentrate more, which is the important path of the application, etc. The developer can do unit testing very well and can effectively identify boundary cases.
This is all applicable to a developer who is a Good Tester! But most of the developers consider testing as a painful job, even though they know the system well, due to their negligence they tend to skip many testing paths, as it’s a very painful experience for them.
If developers find any errors in their code in Unit Testing then it’s comparatively easier to fix, as the code is new to them, rather than getting the bug from the testers after 2-3 days. However, this is only possible if the developer is interested in doing that much testing.
It’s the Tester’s responsibility to make sure that each and every path is tested or not. Testers should ideally give importance to all the small possible details to verify if the application is not breaking anywhere.
Developers, please don’t review your own code. Generally, you will overlook the issues in your code. So give it to others for review.
Everyone specializes in a particular subject. Developers generally think how to develop the application, on the other hand testers think about how the end-user is going to use the application.
In short, there is no problem if the developers do basic Unit Testing and basic verification testing. Developers can test for a few exceptional conditions which they know are critical and should not be missed. But there are some great testers out there.
Through the build to test team. Don’t waste your time either. For the success of any project, there should be an independent testing team validating your applications. After all, it’s our (testers) responsibility to make the ‘baby’ smarter!!
What did you say?
Feel free to disclose your thoughts in the comments section below!