Showing posts with label tester. Show all posts
Showing posts with label tester. Show all posts

Tuesday, September 4, 2012

10 Signs that you're not cut to be a tester

I had quite some fun reading trough signs indicating why you would be not cut for IT, not cut to be a developer or an IT consultant on the Tech republic blog:
http://www.techrepublic.com/blog/10things/10-signs-that-you-arent-cut-out-for-it/3072

I don't mean to say that it made a whole bunch of sense to me, but I did notice that one particular blog post was still outstanding... so I decided to suggest this one myself:

These are my top 10 signs that you're not cut to be a tester:

1. You get nervous from buggy software

The software you're facing on a day to day base is going to be full of bugs and will look like a poor Picasso imitation. You'll need to find workarounds. And when a bug has been resolved, you'll be facing the next problem. You'll have to go trough again.

2. You're unaware of business expectations

If you're not aware of business expectation, you'll look over half of the defects that are in front of you. You'll read over inconsistencies and you won't question the rationale behind an architectural solution that has been proposed. An overview of what business wants and why they need an application, gives you structure and focus on finding the defects that potentially are of high impact.

3. You get tired from explaining defects occurrences

Not everyone knows the system like you do. Not everyone understands the reason why a bug is a bug. You'll need to explain it... again and again. Even when it works on their machine...

4. You don't read blogs, books or attend conferences about software testing

A tester keeps up to date on the latest evolutions on tools, techniques, methods and can learn from practical experience of other testers. It's no use to invent what already has been invented for you. It is  even less useful not to learn from others mistakes.

5. You're ashamed of your role in the project

A tester could also be an analyst, a developer, a designer or an architect, but chooses to be a tester. A tester is not a developer or analyst, coming close to retirement. A tester is proud of their job and aims on improving software quality. They aim on challenging development, analysis and architecture on their correctness, completeness and coherence. A tester is proud of and dedicated to find the human flaws in a program before it is released to production.


6. You know how to check but you don't know how to explore

Checking against expectations is a given. This needs to be done. After this, the software needs exploration. How else are we going to find those undefined features and prove that if you click on the left mouse button 6 times, then do a page refresh, while keeping your right mouse button clicked and then releasing the right mouse button after which you disconnect the keyboard, your money has gone from your account, but has not been transfered?...


7. You are not keeping up to date on the technical aspects of IT

IT terms are not just hype words for a tester. A tester has to have an understanding of OO, has to know what a web service is or a message queue, what the function is of an isolation layer or why server and client side validations can be implemented while building a website. A tester needs to constantly improve and understand what they are technically dealing with as every technicality has it's weakness. That's where most probably the defects will be.

8. You don't like to communicate

Communication, communication, communication. Testing is about finding bugs and inconsistencies and communicating about them.

9. You are not aware of the application development life cycle

A tester needs to know about architecture, design, analysis, development, infrastructure, release management, ... and also how they fit together. A testers could even carefully address flaws in the application life cycle, since they might result in software bugs later on.

10. You can't get over defects you found and don't get fixed

Face it. You'll find those defects that are obvious and you would never want to see in your software. However, you're not paying for every single defect to be fixed. Decisions will be made that might not make you happy. Your job is to point to the risks and issues of not fixing a defect. Your job is not to get them resolved.

Thursday, July 26, 2012

Why testers know best...

Because testers ask questions when they don't understand
Because testers think about what can go wrong and not how it should work
Because testers are not dedicated to go live in time
Because testers still want to go live in time more than finding bugs that don't matter
Because testers love finding bugs that matter
Because testers don't have much advantage in telling 'I told you so'
Because in the end, if a problem is not fixed in time, the tester suffers from that so they are driven to find issues and defects early
Because testers don't have 'babies' to protect and therefore are the least biased people in the project
Because testers have a critical technical eye for detail and understand what business wants in the same time


Tuesday, June 26, 2012

The Kick-off


Dear Reader,



Kick-starting myself into the world of possible readers, I find myself ready to write on what I think software testing is absolutely not about, definitely should be about and share how I experience my attempts to contribute to change. It’s time for the era of better software-testing.

As a kid I started testing on my first assignment with the TMap® and later the TMap NEXT® at my side. I wanted to learn all about the black box of software development and as a good boy, I absorbed, without a lot of questioning. Moreover, how could I think about questioning when being taught by Michiel Vroon and Rob Baarda themselves? I was genuinely impressed and learned mostly about the test design techniques and test phases.

It all made perfect sense to me: First there are requirements which get broken down into specifications. In a very good project they will even be broken down into a technical design. When this is all done, coding can start and then everything gets tested in different test levels, each of them having their test cases designed according to the documents available. When the testing phases are over, we go live... Doesn’t that sound like a V-model? (http://www.waterfall-model.com/v-model-waterfall-model/)

It’s like building a house, in fact. First you come up with a plan, the architect makes a blue print, the master builder makes a plan and the house is built in phases, starting with the foundations…

… but wait a minute… when is the house tested? After the last construction part is done? Actually while building a house, testing takes place within every development phase. For example, the foundation is verified when walls are being build. Then why do testers only test when it’s actually too late? And what if the living room didn’t really look like we hoped it to look like during construction? What if we, living in France, bought cheaper power plugs in UK, who will notice and when? … You know where I’m getting at, I suppose. Software development is not like building a house, nor it is like building a car, it’s mostly like software.

Things are often not as easy as they look like. Therefore the V-model, like any other model has disadvantages
  • In the V-model requirements don’t change within the development life cycle – Unfortunately even if they don’t change, our language is still too primitive to formulate an unambiguous complete requirement that is understood in a perfectly similar way by all stakeholders and involved parties. Or in other words, let’s accept we’re human.
  • Mistakes are only found when all development is already done – No requirements or any other spec is verified up until the moment that all development is done and a go for testing is given. That's too late.
Now, unless you work in the army or for the public sector, the currently most recognized documented best practices and methodologies for testing are difficult to put to actual use. That is mostly because in your project you don’t have a complete industrialized process and/or an immense budget available. The V-model doesn’t really offer the possibility to change your mind or make mistakes during the development lifecycle and requires high discipline on top of that.


I do have to recon on the other hand that it’s easy to plan a test phase 3 months in advance, hire 15 testers to write test cases. Most Project or Program Managers understand that those test cases always go straight to the recycle bin before they actually get executed. They do however like a pro-forma report with execution rates, preferably linked to the amount reopened defects of priority 1, to go to the developers and show them, having the proof in hands that their development is crap and that they are buying time.


Now I hope to all find you nodding heads, agreeing with what I’m saying, but guess what, lots of us are testing in this kind of structure that really does not make sense.
So why do lots of us work in projects that are run like this?
- I know: Because people want things that make sense, that are easy to explain.
Then why does this non-sense make sense?
- It doesn’t. What makes sense is that a V-model makes a complex world look easy and people want easy things
So what can we do make this testing (and project) world a better place?
- Find a way to test that is easy to explain and understand, does make sense and, most of all, really works.


In this blog, mostly, for now, I will describe my frustrations of testing in the European Hemisphere, my inventions and ideas to improve testing and relate with other professions in the project development landscape.
And most of all, I will try to contribute to the common sense in testing.