Developers should test their own code

Should developers be involved in testing phases?

We use a classic V-shaped development process. We then have requirements, architecture, design, implementation, integration tests, system tests and acceptance.
Testers prepare test cases in the first phases of the project. The problem is that the test phases are too long due to resource problems (*) and are often shortened for time reasons (you know project managers ...;)). Developers do their unit tests the way they should.

So my question is simple: should developers be involved in the testing phases and isn't it too "dangerous"? I'm afraid it will give the project managers a false sense of better quality since the job has been done, but would the extra man-days be worth it? I'm not really confident that developers are doing testing (no offense here, but we all know that breaking a few clicks of what you've been doing in several days is pretty hard).

Thank you for your opinion.

(*) For unknown reasons, increasing the number of testers is still not an option.

(Just upfront, it's not a duplicate of Should Programmers Help Testers Design Tests? This is about test preparation, not test execution, which avoids the impact of developers.)


Take your question very literally ("involved in"). My only answer is absolutely clear


Developers should never have the final say on theirs own Have code.

However, developers should be involved in testing other developers' work. It does two things:

  1. It brings a developer's insight into testing. This is due both to the general case that we only know which APIs are likely to be used at any given time, what exceptions these APIs can throw at and how they should be handled. It also helps with a specific project as the developers are much more exposed to the various discussions about why something is being done than they normally are in quality assurance, which means they may spot edge cases that quality assurance would not. Bugs discovered by a developer are also likely cheaper to fix, since a developer typically offers more information and much more insight into how to fix them immediately.
  2. It gives the developer exposure to parts of the application that they might not otherwise be exposed to. This will make them better developers for this app in the long run. Knowing how my API is being used can help me predict the next thing I should do much better than just starting from one specification. Most importantly, I can tell when the specification is wrong, before I start coding when I know the application and how to use it.

Why wouldn't you use as many eyes as possible? You can rarely afford to go through the hiring and boarding process to bring additional QA staff on board for crunch time. Where can you find the extra eyes you need? Or are you trying to get through crunch time with the same number of QS that you had all along? Even if the developers spend 20% of their time testing and fixing 80% of the bugs they encounter, the app still has more eyes than before. Automated tests only give you a certain level of confidence and will never be 100%.

Absolutely not for anything but unit testing. Developers simply know too much about the app and how it is supposed to work to be objective testers.

The fundamental difference in the testing philosophy between developers and Qs is that the programmer usually tests his program to prove that his code works ("positive" tests). QA can and does this, but additionally focuses on figuring out which does not work, by attempting to damage the software (using "negative" tests).

To the extent that QA staff may be harmed by the programmer tests that "prove" the software to work, there should be one between the developer tests and the QA tests Insulation exist . The developer can certainly help the QA testing by demonstrating what works. However, it is up to the QA independent to check that the software doesn't breaks down.

The best thing the programmer can do to aid the testing effort is to provide a comprehensive, high quality, and verifiable unit test suite that includes tests that match the individual requirements in the requirements document.

Well, in terms of testing, there are 3 types.

Black box, gray box and white box.

Black box refers to users who test the product without knowing how the product works internally.

Gray box refers to power users who have some knowledge of computer programming but are not on the development team. These people test to see if the product has memory leaks, system requirements issues, and so on.

Here's the main part: White box refers to developers testing the product at the code level. This means saying that they are doing unit testing, debugging, ... etc.

So it is good that the user and development team are all involved in the testing phase. However, any test requires reasonable user and development team engagement, depending on what is being tested.

UNIT TESTING is a must for all developers

For information on how this can be used to your advantage, please see the links below if you are interested in C ++ development:

There is no way a QA person can do these tests. NO WAY.

Assuming the project has a significant number of developers, the developers definitely need to work on tests. One caveat would be that developers don't work on testing their own code (this doesn't include unit testing).

I'd rather see administrative staff (or potential users) doing the QA testing than developers. Someone who doesn't know how the product works must try to use it. Developers tend to be very limited in the way they approach testing and frankly they are too expensive per hour to use for QA testing as well.

You write:

The problem is that the test phases are too long due to resource problems (*) and are often shortened due to time constraints. This is because developers don't run them. One of the largest internet company that delivers the best, most stable products, uses None at all Tester. They only use automated tests, all of which are done by the developers themselves. The results are x10 better products than if the developer left the testing to "testers".

It's like construction workers are building your house, but another team needs to make sure the building actually stands, the doors open and close, the air conditioning works, etc. It will probably take x10 to build buildings, and most will end up being unreliable.

We use cookies and other tracking technologies to improve your browsing experience on our website, to show you personalized content and targeted ads, to analyze our website traffic, and to understand where our visitors are coming from.

By continuing, you consent to our use of cookies and other tracking technologies and affirm you're at least 16 years old or have consent from a parent or guardian.

You can read details in our Cookie policy and Privacy policy.