Software Development Cross Solution - Index of - Free
Software Development Cross Solution - Index of - Free
Software Development Cross Solution - Index of - Free
You also want an ePaper? Increase the reach of your titles
YUMPU automatically turns print PDFs into web optimized ePapers that Google loves.
Q: How many people should be<br />
involved in a spike test?<br />
A: Ideally you’d get everyone that you<br />
think will be involved in the actual bug fixing<br />
involved in the spike test. This means that<br />
you not only get a more accurate estimate,<br />
because the actual people who will finish <strong>of</strong>f<br />
the bug fixing will be involved in the future<br />
estimated fixing task, but those individuals<br />
also have a week to get familiar with the<br />
code.<br />
This especially helps when you ask those<br />
members <strong>of</strong> your team to assess their<br />
confidence in the estimate that comes out<br />
<strong>of</strong> your spike test. They’ll have seen the<br />
code base and have a feel for how big all<br />
the problems might have been, so their gut<br />
feeling is worth that much more.<br />
Q: How do I pick the right tests to<br />
be part <strong>of</strong> the spike testing when I have<br />
thousands <strong>of</strong> tests failing?!<br />
A: Try to pick a random sampling, but<br />
with an eye towards getting a selection <strong>of</strong><br />
bugs that vary in difficulty. So what you’re<br />
looking for first is a random sample, but<br />
then you want to make sure that you have<br />
a cross-section <strong>of</strong> bugs that, at a glance, at<br />
least appear to be challenging and not just<br />
the easiest things to fix.<br />
Q: I thought in test-driven<br />
development, we fixed each test as we<br />
came across it. Are we not using TDD<br />
anymore?<br />
A: This is still TDD, for sure. But this is<br />
about existing code, not writing tests for<br />
new code. You don’t want to stop and try to<br />
fix each test just yet. We need a big picture<br />
view <strong>of</strong> the code right now.<br />
However, this does cause a problem if you’re<br />
using CI, and your build fails when a test<br />
fails. In that case, after you get a count <strong>of</strong><br />
failing tests it might make sense to cheat a<br />
little and comment out the failing tests. Then<br />
add them back in one at a time. This is risky,<br />
and might get you on the TDD Most Wanted<br />
list in no time flat, but practically speaking<br />
you might want to consider it. The most<br />
important thing is you get all <strong>of</strong> those tests<br />
passing, and nothing’s left commented out.<br />
Q: Why did we add in that confidence<br />
factor again?<br />
A: Factoring in confidence gives you<br />
that qualitative input into your estimates<br />
where your team gets a chance to say<br />
how difficult they feel the rest <strong>of</strong> the bugs<br />
may be to fix. You can take this pretty far,<br />
by playing planning poker with your bugs,<br />
but remember that the longer you spend<br />
assessing confidence, the less time you<br />
have to actually fix the bugs.<br />
It’s always a compromise between getting<br />
an absolute estimate for how long it will<br />
take to fix the bugs (and this can really only<br />
be obtained by actually fixing them all) and<br />
getting a good enough feel for how fast you<br />
can squash bugs and getting that estimate to<br />
your customer.<br />
Q: Why five days for a spike test?<br />
A: Good question. Five days is a good<br />
length because it focuses your team on<br />
just the spike test for a week (rather than<br />
attempting to multitask during that week),<br />
and it gives everyone enough time to do<br />
some serious bug fixing.<br />
Q: Can I use a shorter length?<br />
Download at WoweBook.Com<br />
bugs<br />
A: You can, but this will affect how many<br />
bugs your team can work through, and that<br />
affects your confidence in your final estimate.<br />
In the worst case scenario, no bugs at all<br />
are fixed in your spike test, and you’re left<br />
confused and without a real end in sight.<br />
Five days is enough time for some serious<br />
bugs to be fixed and for you to be able<br />
to come out <strong>of</strong> the spike test with some<br />
confidence in your estimate for fixing the<br />
remainder <strong>of</strong> the bugs. And in the best case<br />
scenario, you come out <strong>of</strong> the spike test<br />
week with no bugs at all!<br />
Q: So should I do this on code we’ve<br />
developed, too?<br />
A: You really shouldn’t need to. First <strong>of</strong> all,<br />
you shouldn’t have a massive stack <strong>of</strong> failing<br />
tests. If a test is failing, the build should be<br />
failing, and you should fix things immediately.<br />
And with bugs, they should be prioritized in<br />
with your other work, so it’s unlikely you’ll<br />
suddenly get a giant stack <strong>of</strong> bugs you need<br />
to sort through. And finally, you and your<br />
team should know your code base pretty<br />
well. Your coverage reports provide value,<br />
and you know there can’t be too much code<br />
involved in any given bug.<br />
Q: How can I be absolutely sure that,<br />
even when I’ve factored in my team’s<br />
confidence, that 10 days is definitely<br />
enough to fix all these bugs?<br />
A: You can’t. Ten days is still just an<br />
estimate, and so it’s how long you think it<br />
will take, based on your spike test and your<br />
team’s gut feelings. You’ve done everything<br />
you can to be confident in your estimate, but<br />
it is still just an estimate. When it comes to<br />
bugs, you need to be aware that there is a<br />
risk that your estimates will be wrong, and<br />
that’s a message that you need to convey to<br />
your customer too...<br />
you are here 4 405