30 Things Every New Software Tester Should Learn
Tags: testing
Published: 2019-02-19 16:44:20

---
This _[post](https://ministryoftesting.com/dojo/lessons/30-things-every-new-software-tester-should-learn?s_id=25204) was originally published on [Ministry of Testing](https://ministryoftesting.com)._

This is a guide to learning more about software testing. As you start on your journey you will have tasks you can work through. Software testers are always learning but we cannot always quantify it. We learn about the product we are testing. We learn and develop relationships with developers, managers and testers. This makes us great at what we do. We are also chameleons. We change based on the environment we are in or the product we have to test. We have to continue to educate ourselves about the tools we need to test each product.

I have split the tasks up to create more digestible chunks of information. This is by no means a complete list. It will get you started on your journey. Take each task and work towards checking off the activities.

After completing the activities listed here, there is further exploration to do. As you follow the steps, reflect on what you have done so far. Maybe you would like to redo a task or adventure down another course of research. Tasks could even be done in a different order. Every tester is different and that is an asset to your testing ability.

## (Task 1) Are you interested in software testing?

Let's start with a little self-reflection. 

An important part of being a tester is your mindset and being aware of it. 

* What led you to this article? 
* Why is software testing valuable to you?
* What do you believe software testing is? We'll talk about this more in the next Task but it's good to think about what you currently believe it is.

Take a moment to think about the questions above and other questions you might have. By the end of this guide, the aim is to have the majority of those answered. You're going to have more questions as you go too. Questions prompt a search for answers which results in learning.

We are surrounded by tech daily. There may be things you use in your everyday life that bother you. Perhaps a software package at work that takes longer than a minute to load. The app on your phone that freezes just after an update. Or perhaps when you get locked out of your emails and discover you can't recover or reset your password. You might have started to think more about that software package by maybe looking at your task manager as it loads.

Can you be a person who strives to make software better? Can you be an advocate for the users? The business? Your work colleagues?

Do you know what it takes to get there? Do you know what you need to learn? Think about all the good and horribly bad software you have come across in your life. You are the chameleon in both. In a good situation, you want the product to stay good so you keep learning to stay on top of it. In a bad situation, you want to learn more so you can feel like you did everything you could before the software was released. Learning is the key. No matter the situation you will always be learning even if you aren't aware of it.

This sounds daunting, don't let it put you off. Start with the first question and think about it. By the end of this guide, you will be more confident in your answers to all of these questions.

What to do next:

* Commit to print why you are here (a post-it or whatever medium you prefer)
* Where do you plan to be at the end of this?
* What skills do you have now that you think are useful for testing?
* What do you currently perceive software testing to be?
* Plan this guide into your schedule. Be realistic about what you can achieve. Consider your day to day work and your energy levels.

## (Task 2) What is software testing?

Start by writing down what you think software testing is and what a software tester would do.

There are many aspects to software testing. It does not always involve using the product. It is not just about finding bugs. Testing can start around the requirements stage. Thinking about what the product should do, where risks could be, and how the user/customer navigates the product is all part of testing.

One discussion I recently had, about whether it is fair to assume that customers are your users, gave me perspective on terms we use to represent stakeholders. Stakeholders, to me, covers everyone who has an interest in the software product. In the end, we agreed that the person who pays for your software may not be the one who actually uses it. This is a great example of how software testers should look at things from different perspectives. Below are examples gathered from discussions with other testers about what they think testing is or is not.

|What Testing Is | What Testing Is Not|
|----------------|--------------------|
|Verifying whether software meets the expected value to its users. Investigating the product to find any information that is of value to our stakeholders.|Simple, quick, predictable. Only verifying that the product matches the description.|
|Mitigating surprises - Trying to find problems before software is released to stakeholders.|Increasing quality - this is a whole team exercise. Prove that the software has worked once.|
|Exploring products. A valuable activity in software development but often misunderstood due to its unpredictable and creative nature.|Well understood or valued by everyone. A process that is fixed, unimaginative and best kept under strict rules.|
|Communicating - with stakeholders (customers, users, developers, etc.) and work together to find out if the product is improving.|A phase that a project needs to go through in order to be successful.|
|Infinite. All testing is sampling. For every non trivial product, there are an unimaginable number of parameters with a great number of possible values. How do you know you are testing the important ones?|Ever finished - we can make decisions about stopping criteria but there are an infinite amount of combinations that could be checked.|

What to do next:

* Read this [list of things of what software testers do](https://www.ministryoftesting.com/dojo/lessons/what-do-software-testers-do-version-0-1). 
* Try asking people around you about the title of this task. Ask people you work with testers and non-testers, ask people on Slack and maybe even ask your family. Has this changed much from what you originally thought? How different were the responses you got?
* Research other industries such as pharmaceuticals, appliances etc. What is their approach to testing? How different or similar is it to the tech industry? Do any of the differences change your thoughts on how you would approach testing?

## (Task 3) Testing for non-testers

When I started in software testing I had no idea what testing was. I also had no clue of where to start. One of the most useful resources I came across was the pathway [Testing for non testers](http://katrinatester.blogspot.com/2015/11/testing-for-non-testers-pathway.html) by Katrina Clokie. Using Katrina's pathway I was able to understand testing and the value it provided. I was also able to investigate her references further to start expanding my knowledge and list of people I should look to for advice.

This is one of the things that will not be done overnight! I recommend reading it and referring to Task 1 of this guide each time. Reflect on each link you read within Katrina's blog post. Are there any things you want to practice? Are there any things you don't and if so, why? Has this changed the thoughts you wrote down on Task 2?

What to do next:

* Share the link with your team.
* Read an article a day from Testing for non-testers.
* Create your own list of things to learn and practice. You will most likely be updating this constantly.

## (Task 4) Get social

This will be a slightly easier task to get started with but you will need to put in the effort to keep it up. Start as simply as you like or feel comfortable with. I do recommend achieving all of the steps below when you can. 

Engaging in social activities has enabled me to meet local testers who are willing to help me when I come across a tough problem. Through these social gatherings, I have made some friends in a city I am new to. It's nice to have a sympathetic ear with friends who understand what you are talking about.

What to do next:

* Go to Meetup.com and look for a local software testing meetup.
* Join the [Ministry of Testing Slack](https://www.ministryoftesting.com/slack_invite).
* Join Twitter, start finding testers to follow and get involved in some conversations .
* Join [The Club](https://club.ministryoftesting.com/), a software testing and QA discussion forum.
* Read Andrew Morton's blog posts on attending the [Bristol STC meetup](http://testingchef.blogspot.com/2011/06/bristol-stc-meetup.html) and the [Cardiff STC meetup](http://testingchef.blogspot.com/2011/08/cardiff-stc-meetup-writeup.html).
* Start looking up testing conferences such as TestBash, Agile Testing Days, EuroStar, STPCon, Global Testing Retreat, TestCon, STAREAST, Let's Test, Nordic Testing Days. We'll cover these more in Task 23. They are a big part of getting social.

## (Task 5) Get organised

It can be difficult to stay organised when there is so much information being thrown at you. I struggled with this a lot, I still do occasionally. [Tiny Habits](https://www.tinyhabits.com/) was recommended to me by another tester when I was getting started. I go back to it frequently and set myself new tiny habits to achieve, particularly when I feel like things are going awry. This does not take a lot of time but it will save you in the long run.

You might also want to think about writing mind maps. There are a lot of free tools out there to help you with this. I find a mind map can help me streamline a random thought process a lot easier. Ever had a million ideas running through your mind that are loosely related but you can't get them into a sensible order to make something of? Mind maps can help with this, so can the good ole reliable post-its on a wall approach.

If you're more of a gamer, or the above don't appeal to you, you could also try [Habitica](https://habitica.com/static/front). It's a free app where you can earn points/coins when you achieve your daily goals. You also lose health if you miss a daily goal. Kinda cool!

What to do next:

* Sign up to Tiny Habits and do it for a week.
* Start a mindmap.
* Investigate if Habitica is for you.
* Create a personal [Kanbanflow](https://kanbanflow.com/) or [Trello](https://trello.com) board. Start with the column headers "To Do", "In Progress" and "Done". Add a card for each thing you would like to achieve and move them across the columns as you progress with them.

## (Task 6) Check out The Ministry of Testing Platform

Sign up to [The Ministry of Testing Platform](https://www.ministryoftesting.com/membership?return_to_referer=yes) and explore it. I have found it to be an amazing resource for my career. I can watch training videos, access testers blogs and I get notified of upcoming events that they host. I started with a free membership and finally graduated to a paid membership this year.

What to do next:

* Start with free [Ministry of Testing membership](https://www.ministryoftesting.com/membership).
* Read these [web testing 101](https://www.ministryoftesting.com/dojo/series/web-testing-101) articles on the Ministry of Testing platform.
* Watch these [software testing talks](https://www.ministryoftesting.com/dojo/series/testbash-playlists-the-most-popular-testbash-talks-of-all-time)` from the most popular TestBash talks of all time playlist.
* Watch this video from Danny Dainton a nice 99 second talk about how [he stopped wasting his time](https://www.ministryoftesting.com/dojo/lessons/how-i-stop-wasting-my-own-precious-time-danny-dainton).
* Investigate the content on the Ministry of Testing platform further.

## (Task 7) What is a bug?

I know a bug in software when I see one, or at least I like to think I do. I thought it would be easy to explain what a bug is. When I tried to find a definition I found many that just didn't cover the scope enough. [James Bach defines a bug](http://www.satisfice.com/glossary.shtml#Bug) as "Anything that threatens the value of the product. Something that bugs someone whose opinion matters". That is a nice high-level definition. On [Testing Computer Software](https://www.amazon.co.uk/Testing-Computer-Software-Cem-Kaner/dp/0471358460/ref=as_li_ss_tl?ie=UTF8&qid=1484648880&sr=8-1&keywords=testing+computer+software&linkCode=sl1&tag=softwaretestingclub-21&linkId=0e175baf51eaf7aed6314d3b57003b4a) you will find "most bugs cause a program to change its behaviour when the programmer didn't want or expect it to or cause the program not to change its behaviour when the programmer did expect it to".

In most of the definitions, I found them to only mention the code or the developer. None of these are wrong. Going back to the definition from James Bach and looking at the ideas of [the three amigos](https://www.agilealliance.org/glossary/three-amigos/) we could also have bugs in specifications. This would threaten the value of the product and it would not then be a bug with the code.

Think about the technology you use:

* Have you encountered bugs in any of it?
* Why did you feel like they were bugs?
* Did you do anything about it (e.g. report a bug in an app through the app store)?
* Can you think of three different things that help you decide whether a bug is actually a bug or not? These are called Oracles and we will look at them in more detail in Task 13.

## (Task 8) Recommended Reading

This is a starting point for your reading list. You won't achieve all of this in one day. Some of the books I list here will be referred to in relevant sections later in the series. This is to make you aware of the existence of the books and work towards purchasing or borrowing them from the friends you will make when you get social. 

I asked people what books they would recommend for testing and I got the following (this is by no means a comprehensive list):

* [Explore It!](https://pragprog.com/book/ehxta/explore-it) by Elizabeth Hendrickson, an excellent book about exploratory testing.
* [Evil by Design](https://evilbydesign.info/book/) by Chris Nodder, I love this book! I learn something new every time I read it. I'll cover more about this later.
* [Agile Testing](https://www.amazon.co.uk/Agile-Testing-Practical-Addison-Wesley-Signature/dp/0321534468) by Lisa Crispin and Janet Gregory is one of those books that everyone raves about and you wonder why it took you so long to read it.
* [Thinking, Fast and Slow](https://www.amazon.co.uk/Thinking-Fast-Slow-Daniel-Kahneman/dp/0141033576) by Daniel Kahneman which I have not personally read. This has been recommended to me by enough people that I will be starting it as soon as I finish this article.

The Ministry of Testing platform also has a list of [free and paid for eBooks](https://www.ministryoftesting.com/dojo/lessons/ebooks-for-software-testers) that is added to over time. Check that out now that you're a member.

Next:

* Start to read one of the books mentioned above. If you're unsure where to start, I suggest Thinking, Fast and Slow.
* Look at the [recommended reading list](https://www.goodreads.com/group/bookshelf/169343-cast-2015-speaker-recommendations) from the CAST 2015 speakers.
* Ask on one of the Slack channels or on Twitter for more suggestions of books to read.
* Explore the [Book Club](https://club.ministryoftesting.com/search?expanded=true&q=The%20Book%20Club%20tags%3Abooks).

## (Task 9) Write a user story

A user story is like a set of instructions you get with flat pack furniture. By writing a user story it will help you to understand their purpose.

It should provide:

* A description of what needs to be done.
* Acceptance criteria outlining what the story needs to accomplish.
* Any criteria which are out-of-scope for the story to be considered accomplished.
* Note any dependencies required to start the story.

Mountain Goat Software has [examples of agile user stories](https://www.mountaingoatsoftware.com/agile/user-stories) to give you an idea of what to expect when you're out in the wild. EPICs are essentially a large user story. They are broken down into smaller digestible or deliverable pieces called user stories.

Take this [user story](https://d2h1nbmw1jjnl.cloudfront.net/ckeditor/pictures/data/000/000/083/content/image_1.png) as an example, the overall EPIC would be "Flat Pack TV Stand". The user story is then a smaller piece of that "Left Leg and Top Shelf Construction". The dependencies are things that we need but not things we would do, for example, we would need a screwdriver to be able to assemble the shelf. The acceptance criteria are things that we actually have to do.

Writing a user story will help you to think about writing requirements for users more. It will also help you to think about the approach to take for testing these user stories. As a tester you will have a unique set of skills when it comes to analysing user stories. You will be able to highlight missed details, misuse cases, abuse cases and how it can be misunderstood. Not everyone gets the chance to provide early input with user story writing. It is an excellent process, you are testing before there is ever a piece of code written!

Your tasks for today:

* Write a user story for making toast, a peanut butter sandwich or even Ikea furniture using the templates above.
* How do you know if you missed something?
* Have you made any assumptions?
* Think about the order things need to be done in. Are there any optional inputs?
* Are there any requirements or prerequisites (assume the user has bread for example)?
* Try to make toast or a sandwich from scratch following your user story exactly. 

## (Task 10) Testing personas

When you are testing you shouldn't only test for you. You need to think about impatient users, users who take their time, users who have a bit of a tester in them and like to "break" things and many more. Katrina Clokie has an excellent [guide to getting started with testing personas](http://katrinatester.blogspot.com/2015/01/generic-testing-personas.html). As you get familiar with an application, things like this may slip from your mind and you may go into autopilot somewhat. I find trying to get into the user persona more helps me to avoid this pitfall.

Before thinking that personas may not already exist within a project, it may also be worth looking into whether personas research and documentation already exists. You can then use it to build things from a testing perspective.

For today:

* Pick an app on your phone or a program on your computer to test.
* Navigate through it using the different user personas in Katrina's article.
* What did you learn from this?
* How did the application perform under each persona?
* Think about and research how [others approach personas](https://www.smashingmagazine.com/2014/08/a-closer-look-at-personas-part-1/).

## (Task 11) Test a user story

This is linked to Task 9 and a follow on from Task 10. There are many ways to document testing but we will not focus on those here. If you've never written testing documentation, you could look at the test case templates on [Tutorialspoint](https://www.tutorialspoint.com/software_testing_dictionary/test_case.htm). 

Task 9 and 11 have many similarities: While writing the user story, you were testing it just as well, weren't you? But the thing that has changed is that you now have an actual product at your disposal and that makes a world of difference.

You now have something to get hands on with, you can leave the theory behind and put it to practice. This is where you start using your ability to learn. The speed and precision with which you can learn new and interesting information will define your skill and value as a tester.

Concentrate on your mindset as you test the story. This is the most important part when testing a user story.

Questions to ask yourself as you test this story:

* Who is this story important to?
* What is the one problem this User Story tries to solve?
* How could this be misunderstood?
* How could accidental bugs find their way into this?
* What behaviour should it absolutely NOT show?
* When are you done?
* At what point did you feel like quitting your analysis and want to start testing?
* Does this feel reasonable?

## (Task 12) Heuristics

[Cem Kaner and James Bach](http://www.satisfice.com/blog/archives/462) describe a heuristic as "a fallible method of solving a problem or making a decision". [Karen Johnson](http://karennicolejohnson.com/wp-content/uploads/2012/11/KNJohnson-2012-heuristics-mnemonics.pdf) says that a heuristic "Refers to experience-based techniques for problem solving, learning, and discovery. Where an exhaustive search is impractical, heuristic methods are used to speed up the process of finding a satisfactory solution. Examples of this method include using a rule of thumb, an educated guess, an intuitive judgment, or common sense."

James Bach has an excellent [document](http://www.satisfice.com/tools/htsm.pdf) about how to design a test strategy using heuristics. Read over it and think about it for a while. It's a lot to take in when you first read it. If you think about how to apply and understand heuristics in testing, understanding these concepts get easier with time and experience.

Michael Bolton has an interesting blog post about heuristics to help you know [when to stop testing](https://www.developsense.com/blog/2009/09/when-do-we-stop-test/). This is important in testing as we can become so absorbed in testing one feature that we may miss others.

* Can you think of any other heuristic? Explain it to someone and give it a name. [Test Sphere](https://twitter.com/testsphere) and [Explore It!](https://pragprog.com/book/ehxta/explore-it) from Task 8 could help you with this.
* Do you know of any heuristics you have used before? Use the articles above as guidelines.
* Research and share other heuristics you might have found. 
* Pick any of the heuristics and start a discussion with peers. 

## (Task 13) Oracles

According to [Michael Bolton](https://www.developsense.com/articles/2005-01-TestingWithoutAMap.pdf) "An oracle is a principle or mechanism by which we can tell if the software is working according to someone's criteria; an oracle provides a right answer--according to somebody". Cem Kaner [describes it as](http://kaner.com/?p=190) "a software testing oracle is a tool that helps you decide whether the program passed your test". 

Michael Bolton also talks about how [all oracles are heuristic](https://www.developsense.com/blog/2012/04/all-oracles-are-heuristic/) but not all heuristics are oracles. This can take time to understand so do take your time with it. Katrina Clokie's article about [Heuristics and Oracles](http://katrinatester.blogspot.com/2014/09/heuristics-and-oracles.html) may help you to think about this in everyday terms.

What to do next:

* Read [Testing Without A Map](https://www.developsense.com/articles/2005-01-TestingWithoutAMap.pdf) by Michael Bolton. It gives a step by step guide on using oracles to determine if you are 'done' testing. 
* Check out [Testing Mnemonics](http://www.qualityperspectives.ca/resources/#mnemonics) list that Lynn McKee has put together. Also, read [FEW HICCUPS](https://www.developsense.com/blog/2012/07/few-hiccupps/) by Michael Bolton which expands the HICCUPS mnemonic. 
* What oracles have you used? Can you see any oracles in your testing work?
* When an app on your phone updated, did it maintain a consistent behaviour? If not, did you like this inconsistency? Was it an improvement on the previous behaviour or did you consider it to be a bug?

## (Task 14) White & Black Box Testing

White and Black box testing are two approaches to software testing. Think of them as two umbrellas for types of testing to fall under.

White or Glass box testing is a testing method where the tester knows the internal workings of the program. 

The tester writes a strategy to test the program based on knowledge of the application's internal code. They understand what the function is doing and what inputs will produce what outputs. This type of testing typically focuses on coverage of statements, lines of code, branches of code, etc. [White box](https://en.wikipedia.org/wiki/White-box_testing) testing most often applies to [unit tests](https://en.wikipedia.org/wiki/Unit_testing). 

One of the biggest risks with this type of testing is the inability to find missing features. You cannot cover a line of code with a test if the line of code never existed. The tester is required to have knowledge of the language that the program was written in. With this type of testing, you are also naturally biased with your thinking patterns given the time you have spent within the product. As a result, you might miss obvious or non-obvious problems due to being too close to it. Think about signing in to your emails. It's something you do every day and you follow the same pattern every day. When was the last time you noticed a change on the login page or process? You become so used to what you expect to see that you may not notice the unexpected.

[Black box testing](https://en.wikipedia.org/wiki/Black-box_testing) is a method where the internal workings of the program are unknown to the tester. Tests are based on the requirements and functionality. One of the advantages of this over white box testing is the possibility of identifying missing code statements. This approach does not require the tester to have any knowledge of the language that the program was written in. A risk with this type of testing is the unknown level of coverage that testing gives.

I had much fun and frustration at a workshop by Alexandra Casapu trying to solve puzzles like these [Black Box Puzzles](http://blackboxpuzzles.workroomprds.com/). These are a good way to hone your skills as a black box tester. Try some of them. Did you manage to figure any of them out? If you did, can you figure them out a second time? Can you remember your approach? Did you change your approach the second time?

What to do next:

* Try out doing some of the [Black Box Puzzles](http://blackboxpuzzles.workroomprds.com/).
* Try testing any mobile app you have on your phone, you would essentially be doing black box testing.
* Go to the [Khan Academy Computer Programming](https://www.khanacademy.org/computing/computer-programming) section, try out some of their tasks and see how you can create or identify problems with knowledge of code.

## (Task 15) Accessibility Testing 

Do you know anyone who is colourblind or maybe uses a screen reader? I know people who are colourblind, visually impaired, deaf, dyslexic or have photosensitive epilepsy. As a result, I am always thinking about these users along with the 'standard' user set for our application. Luckily there are tools that can test an application for its [accessibility level](https://www.ministryoftesting.com/dojo/lessons/a-software-tester-s-guide-to-web-accessibility). A fun and easy trick to try is navigate through an application you are testing with no mouse or trackpad. Sounds easy right? Give it a go and see what you think. There are various plugins you can add to your browser to [view your application](https://www.makeuseof.com/tag/3-easytouse-online-colorblindness-simulators/) the way someone with colourblindness would.

What to do next:

* Pick an application and try some simple accessibility testing on it. Did it perform as you expected? Were there any issues you encountered?
* Read [A Software Tester's Guide to Web Accessibility](https://www.ministryoftesting.com/dojo/lessons/a-software-tester-s-guide-to-web-accessibility).
* [An Alphabet of Accessibility Issues](https://the-pastry-box-project.net/anne-gibson/2014-july-31) is a great article to give you insight into the variety of needs people have.
* If you’re interested in mobile application testing, you might like to read [Accessibility For Your Mobile Audience](https://ministryoftesting.com/dojo/lessons/accessibility-for-your-mobile-audience-identifying-accessibility-gaps-in-mobile-responsive-designs-native-apps?s_id=13098).
* Bonus task, should you want to explore accessibility more, why not try [30 Days of Accessibility Testing](https://ministryoftesting.com/dojo/lessons/30-days-of-accessibility-testing?s_id=13098)?

## (Task 16) Podcasts

Ever wanted to learn about new things while you work, drive or take the train? I always want to learn more in work but have so many things to do. I can't always sit down to watch a video of a talk or read a book or paper. Podcasts have given me the opportunity to learn while I work or commute.

I met [Vernon Richards](https://twitter.com/TesterFromLeic) at TestBash and started to follow him on Twitter. He shared a link of a podcast he had contributed to which was related to testing. I had some time to spare so I investigated it. From there I started to explore all of the other testing podcasts that are out there. Now I try to make a point of listening to at least one per week.

There are two sets of podcasts I love to listen to. Joe Colantonio [Test Talks](https://www.joecolantonio.com/testtalks/) is the first one. Go there and start picking podcasts to listen to.

[Testing in the Pub](http://testinginthepub.co.uk/testinginthepub/) is another one of my favourites. The first one I ever listened to was [An Intro to Cynefin](http://testinginthepub.co.uk/testinginthepub/testing/testing-pub-episode-30-intro-cynefin/) and I've been slowly researching the topic ever since. Some of the topics in both places can be a bit heavy. Find the ones you are interested in the most and start with those.

Podcasts are an excellent resource. Try to get into the habit of listening to them. I'm sure you'll soon have your own favourite ones.

What to do next:

* Check out the Ministry of Testing Podcast [Testing Feeds](https://www.ministryoftesting.com/feeds/podcasts).
* Explore the content on [Let's Talk About Tests](https://letstalkabouttests.xyz/).
* Listen to a podcast on one of the [Ministry of Testing podcast series](https://www.ministryoftesting.com/dojo/podcasts).


## (Task 17) User Experience (UX) as a tester 

The [user experience](https://www.usertesting.com/blog/what-is-user-experience/) is pretty much what it says on the tin. It is how the user experiences your application and how they respond when they use the application. Don Norman describes it as even [more than that](https://www.youtube.com/watch?v=9BdtGjoIN4E&feature=youtu.be). Testers are often tasked with understanding user experiences and helping ensure the user has a good experience by reporting back any possible issues to the rest of the team. Even before the product is out on the market, testing can help to highlight UX issues. An example would be a page takes a long time to load. A user wouldn't wait that long because the competitor product hasn't got the same issue. We should investigate the delay and try to fix it.

The Nielsen Norman Group have an article about [heuristics for user interface design](https://www.nngroup.com/articles/ten-usability-heuristics/) which can help with the user experience. 

At the end of the day, it is users who will give you feedback on their experience with the product. As a tester, you can help to ensure that their initial experience is a good one.

What to do next:

* Start to really think about user experience.
* Can you recall a stand out positive user experience you had?
* Can you explain why you felt it was positive?
* Do the same for the negative case.

## (Task 18) Regression testing

A big part of software development is getting things to work together and keep them working together. Even if loads of time and effort go into harnessing these implementations you'll find cracks within the surface.

Regression testing is a technique that tries to find problems in software that has worked before but is now broken because something was changed.

Many Testing concepts are introduced because of regression and the uncertainty this gives developers and managers. Automated checks, rerunning Test Cases, elaborate smoke tests,... are all in place because of regression issues.

[Regression testing](https://en.wikipedia.org/wiki/Regression_testing) involves re-testing features that previously worked to ensure that they are not affected by the addition of new features or refactoring of existing ones.

What to do next:

* Think about a time when one feature in one of your favourite apps didn't work anymore. This might be in a game such as Pokémon Go, Facebook, Netflix application, or any other product that does frequent updates. We've grown quite used to these frequent updates and bugfixes. Additionally, a malfunctioning feature might be fixed tomorrow. Sometimes, this backfires and users get fed up and discard the product entirely.
* Consider the strategies these companies use to tackle their regression issues and compare them with strategies used in your company. Are they very different? Does that make sense to you? Can you come up with other strategies?
* Do you have something that you can practice regression testing on? Let's think back to that app on your phone. Did it recently update? Have a look around at the new functionality that the app creators say they have added. Has it broken functionality that previously worked? If so report it to them. They might already be aware of it but if not you've helped improve someone's experience.

Also, read the following articles on regression testing:

* Cem Kaner and James Bach have written about [Regression testing](http://www.testingeducation.org/BBST/extras/BBSTRegression2005.pdf) in great detail.
* [Thinking about how to get a good regression test set](https://testpappy.wordpress.com/tag/regression-testing/) by Patrick Prill.
* [A heuristic for regression testing](http://karennicolejohnson.com/2009/11/a-heuristic-for-regression-testing/) with Karen Johnson.
* [Get smart about your regression tests' value](https://www.stickyminds.com/article/get-smart-about-your-regression-tests-value) by Leanne Howard.

## (Task 19) Agile testing

If you're quite new to the software scene you will not have heard of development practices such as [Waterfall](https://www.tutorialspoint.com/sdlc/sdlc_waterfall_model.htm), [Agile](https://en.wikipedia.org/wiki/Agile_software_development) or [DevOps](https://en.wikipedia.org/wiki/DevOps). These are methods or approaches to software development. A key thing to notice in the diagram below is where testing fits into each of the approaches. DevOps is relatively new to the scene. We'll start with Agile to ease you in and you can research DevOps later.

Image Ref: http://blog.spec-india.com/wp-content/uploads/Project-Execution.jpg

I'll direct you back to the books I mentioned in Task 8, specifically the one from [Lisa Crispin and Janet Gregory](https://www.amazon.co.uk/Agile-Testing-Practical-Addison-Wesley-Signature/dp/0321534468). Elizabeth Hendrickson has a useful [overview of Agile Testing](http://testobsessed.com/wp-content/uploads/2011/04/AgileTestingOverview.pdf) to help you get a feel for it. Augusto Evangelisti talks in this [interview](https://www.asktester.com/interview-with-augusto-evangelisti-a-true-believer-in-delivering-software-that-matters/) about how Agile has changed the role of the tester. 

Your tasks for today:

* Start reading Lisa and Janet's book.
* Watch this talk from Lisa and Janet where they [debunk Agile testing myths](https://www.youtube.com/watch?v=0tasZ2hSqYI).
* Read Esther Derby's [seven Agile best practices](http://www.estherderby.com/2015/10/seven-agile-best-practices.html).
* Read Huib Schoots' [what makes Agile testing different](http://www.huibschoots.nl/wordpress/?p=1072)?
* [Agile Testing](http://testobsessed.com/wp-content/uploads/2011/04/AgileTestingOverview.pdf) by Elizabeth Hendrickson may also be useful to you.
* Huib has more resources for [Agile testing](http://www.huibschoots.nl/wordpress/?page_id=441#agile) that you may want to explore.
* Bonus task, should you want to explore agile testing more, why not try [30 Days of Agile Testing](https://ministryoftesting.com/dojo/lessons/30-days-of-agile-testing)?

## (Task 20) Pairing

Pair testing involves two people working together at the same machine with a single keyboard to test a piece of software. One person has the keyboard while the other [suggests ideas or tests, pays attention and takes notes, listens, asks questions, grabs reference material, etc.](http://www.testingeducation.org/a/pairs.pdf). There should be a shared goal with this approach and the two people will constantly communicate to ensure that the goal is achieved. Communication is key with this testing approach. Both people involved should have a shared understanding of what they are doing and why they are doing it.

This is easy and fun to do. You only need you and one other person. Katrina Clokie has some excellent material surrounding this from [beginning](http://katrinatester.blogspot.com/2015/05/pair-testing.html) to [end](http://katrinatester.blogspot.com/2016/09/the-end-of-pairing-experiment.html). I try to do this as much as I can in work. It is a great way to get a different perspective on your work and maybe even learn a new skill.

What to do next:

* Read the articles from Katrina and find a pairing buddy. If you’re not in a software house ask someone from the meetups you attended or on Twitter or Slack, you could even try remote pairing as Elisabeth Hocke did on her [Testing Tour](https://www.lisihocke.com/2018/10/my-testing-tour-2018-a-challenge-worth-tackling.html).
* Read this [excellent article](https://www.ministryoftesting.com/dojo/lessons/pairing-with-developers-a-guide-for-testers) on Pair Testing by Lisa Crispin
* Pair with this person and reflect on your experience.
* What did you learn from it?
* What could be better next time?
* Would you do it again?
* What did you teach the other person?
* Katrina also spoke about this at [TestBash Brighton 2016](https://www.ministryoftesting.com/dojo/lessons/a-pairing-experiment-katrina-clokie) watch it if you can.

## (Task 21) Mob Testing

Mob Testing (Mob Programming or Mobbing) is not something you can do by yourself but you should read up about it in the [Mob Programming Guidebook](https://mobprogrammingguidebook.xyz/Download/MobProgrammingGuidebook.pdf). If you can, try to do it in work or get a few people together to try this out. A good chance to do this is at the end of a sprint demo session. Start with a 15-30 minute slot with the whole team. Get them to start asking questions and testing the product as a team. This is a great way to get non testers involved in testing and possibly help generate some new ideas or approaches.

If you're lucky the meetup you attend might try this. If they don't try it, ask them! Any meetup organisers I know are crying out for feedback from the community of what they would like to see. Maaret regularly [blogs](http://visible-quality.blogspot.com/2016/10/details-into-mob-exploratory-testing.html) and [talks](https://www.ministryoftesting.com/dojo/lessons/we-talk-all-things-mob-testing-with-maaret-pyhajarvi) about this. It may not be something you can do at the moment but it is definitely something you need to be aware of.

For today:

* Download and read the Mob Programming Guidebook.
* Try mob testing if you can.
* Maaret has written a [great article](https://www.ministryoftesting.com/dojo/lessons/mob-testing-an-introduction-experience-report?s_id=53161) about her experience and how to get started with Mob Testing.
* Maaret has also spoken at a Ministry of Testing [masterclass](https://www.ministryoftesting.com/dojo/lessons/mob-testing-with-maaret-pyhajarvi), [TestBash Philadelphia](https://www.ministryoftesting.com/dojo/lessons/a-mob-testing-experience-maaret-pyhajarvi) and [TestBash Australia](https://www.ministryoftesting.com/dojo/lessons/next-level-teamwork-pairing-and-mobbing-maaret-pyhajarvi).
* Check out this [excellent talk](https://www.ministryoftesting.com/dojo/lessons/going-undercover-in-the-mob-jasmin-smith) from Jasmin Smith on her experience of Mobbing.

## (Task 22) Dark Patterns

Dark patterns are user interfaces that are designed to trick people into doing things they didn't intend to such as subscribing to or purchasing something. These are well thought out tricks that are meant to benefit a business but rarely consider the user. Have you ever found a sneaky additional item in your basket at checkout or clicked on an advert disguised as another type of navigation? These are dark patterns.

Think back to your user experience task. Dark Patterns are a form of anti-pattern to that. They have been a topic in the [spotlight of news websites](https://www.bbc.co.uk/news/technology-36403020) for some time now.

Have you ever tried to sign up for a free trial of something only to be asked for your payment information? Only after reading [The Sinister Side of UX](https://www.usertesting.com/blog/dark-patterns-the-sinister-side-of-ux/) did I realise I had fallen victim to this.

Emma Keaveny has an excellent [video](https://www.youtube.com/watch?v=DrmdZ9NHmzA) about this! Another useful link for this is [Dark Patterns](https://darkpatterns.org/). Melissa Eaden has also blogged about [spelunking dark patterns](http://testingandmoviesandstuff.blogspot.com/2016/06/spelunking-dark-patterns.html).

Continuing on from the theme of Task 5, I can highly recommend the book Evil by Design -- Chris Nodder. There is also a [website](https://evilbydesign.info/) linked to this book which will give you a flavour of what is in the book. I'm still not finished reading this myself but I learn something new every time I pick it up.

Your tasks for today:

* Watch the video of Emma's talk.
* Read the linked content and start to think about dark patterns.
* Can you think of any dark patterns that you have come to accept as the norm in your life? You can use the examples from Melissa as a guide but I'm pretty sure once you start to really think about this you will have a pretty long list.

## (Task 23) Conferences

There are many software testing conferences out there to choose from. Some even post videos afterwards of the talks which is amazing, but honestly, it is not the full experience. When you attend you get to network, this sounds awful businesslike but seriously it can be the best part about attending a conference. Another advantage of actually attending is the chance to ask the speaker questions at the end of their talk or find them afterwards to discuss it in more detail. Speakers usually welcome the opportunity to discuss their talk in more detail, sometimes it can even give them ideas about how they might change their talk in the future.

[Eric Jacobson](http://www.testthisblog.com/2012/04/how-to-enjoy-testing-conference.html?m=1) and [Rob Lambert](https://conference.eurostarsoftwaretesting.com/rob-lamberts-unofficial-guide-eurostar-2012/) have both written about how to enjoy and get the most out of testing conferences. These will be valuable to you once you pick your goal conference.

My first software testing conference was TestBash Brighton 2016. I blogged about it from the viewpoint of [Is it just for testers](https://medium.com/@HeatherReiduff/test-bash-is-it-just-for-testers-9b4390de9716)? Beren Van Daele felt like [it was a Homecoming](https://enquiretst.wordpress.com/2016/03/12/testbashbrighton-2016-homecoming/). We all took a different angle based on our experience of the day. Cassandra Leung blogged about TestBash Manchester as a [Tester's First TestBash](http://www.cassandrahl.com/blog/testers-first-testbash/). Danny Dainton has written about [being a volunteer](https://dannydainton.com/2013/03/26/test-bash-2-0-from-the-eyes-ears-and-brain-of-me/) at TestBash Brighton. Dan Billing has also written about his [TestBash 2014](https://thetestdoctor.co.uk/2014/04/01/reflections-on-testbash-2014-2/) experience, he went from experiencing it as an attendee to speaking at it.

TestBash is not the only conference out there. Erik Brickarp kindly linked me his blog from [Let's Test 2013](http://erik.brickarp.se/2013/05/lets-test-summary.html), I love the line in it "You are never alone". Helena Jeret-Mäe also wrote about her experience of [Let's Test 2014](https://thepainandgainofedwardbear.wordpress.com/2014/06/01/lets-test-2014/). Chris Kenst has a wonderful [in depth look](https://www.kenst.com/2015/08/in-depth-look-cast-2015/) at CAST 2015. Finally, Keith Klain has written about his experience of [Agile Testing Days](http://qualityremarks.com/agile-testing-days-2016-beer-brats-and-brains/). There are even more conferences out there, these are some first hand experiences of a few to help you get a feel for what to expect.

Going back to Danny's volunteer blog, many conferences have some form of volunteer option if you are willing to put the hard graft in. This may help you to achieve your goal so put yourself out there and see.

What to do next:

* Find a [testing conference](https://testingconferences.org/) to attend.
* Network online with people who have or will attend the conference.
* Search for existing online videos of previous testing conferences.

## (Task 24) Exploratory testing

Exploratory testing is one of my personal favourites. You get to explore areas of the application that you most likely didn't cover with other testing methods or covered, but you felt like you could investigate more. There are some really interesting articles I will advise you to read for this. Most of them are quite recent!

James Bach has written his thoughts about [What is Exploratory Testing](http://www.satisfice.com/articles/what_is_et.shtml). Simon Tomes wrote an excellent article where he gave [three digestible diagrams to describe exploratory testing](https://www.ministryoftesting.com/dojo/lessons/three-digestible-diagrams-to-describe-exploratory-testing) and more recently an article with [30 exploratory testing tips](https://www.ministryoftesting.com/dojo/lessons/explore-galore-30-tips-to-supercharge-your-exploratory-testing-efforts). I would also like to highlight the book [Explore It!](https://pragprog.com/book/ehxta/explore-it) that I mentioned earlier. This book is definitely a go to for exploratory testing. Maaret Pyhäjärvi has a useful article about how to [explore with intent](https://www.ministryoftesting.com/dojo/lessons/how-to-explore-with-intent-exploratory-testing-self-management). This can help you stay guided in your exploration and have a clearer picture at the end of what you achieved.

What to do next:

* Read the linked articles and start Elizabeth's book.
* When you are done reading them pick something you would like to explore, maybe an app on your phone as you take the train to work.
* Explore with intent for the day!
* Did you find anything unusual?
* Did you feel like you explored it enough?
* Would you approach it differently the next time? 
* Read [30 Tips to Supercharge your Exploratory Testing Efforts](https://www.ministryoftesting.com/dojo/lessons/explore-galore-30-tips-to-supercharge-your-exploratory-testing-efforts?s_id=21286).

## (Task 25) Mobile testing

I would call this a specialisation. I've put it in here so that you have resources to be aware of the specialisation. Maybe you'd like to specialise in mobile testing or your job requires knowledge of it. The Ministry of Testing platform has some resources in the [mobile testing section](https://www.ministryoftesting.com/search?q=mobile). There is a channel on the [Ministry of Testing](https://www.ministryoftesting.com/slack_invite) Slack for mobile testing where you can ask for guidance if you wish.

Think about the apps on your phone. If you go into the about section for them does it say anything about the operating systems they support? Given what you now know about mobile testing does this surprise you?

When you're finished getting to grips with mobile testing you might want to try the [30 Days of Mobile Testing](https://www.ministryoftesting.com/dojo/lessons/30-days-of-mobile-testing) challenge. Designed by [Daniel Knott](https://adventuresinqa.com/) who is definitely someone you want to follow on Twitter if you plan to pursue this.

What to do next:

* Check out The Ministry of Testing platform's [mobile testing resources](https://www.ministryoftesting.com/dojo/lessons/mobile-testing-tools) page.
* Do the [30 Days of Mobile Testing](https://www.ministryoftesting.com/dojo/lessons/30-days-of-mobile-testing) challenge.
* Check out Daniel Knott's [book](http://handsonmobileapptesting.com/) on mobile testing.
* Try [Mobile Testing 101](https://www.ministryoftesting.com/dojo/series/mobile-software-testing) and [A Beginner's Guide to Mobile Testing](https://www.ministryoftesting.com/dojo/series/beginner-s-guide-to-mobile-testing-daniel-knott) on the Ministry of Testing platform.
* Investigate the [mobile testing pathway](http://katrinatester.blogspot.com/2015/08/mobile-testing-pathway.html) by Katrina Clokie.

## (Task 26) Security testing

[Dan Billing](https://twitter.com/thetestdoctor) released a sandbox to practice Security testing in called Ticket Magpie. He also has contributed to [a number of resources](https://www.ministryoftesting.com/search?utf8=%E2%9C%93&q=billing+security) on security on the Ministry of Testing platform to get you started. We've all seen the big hacks over the past year or more: TalkTalk, Ashley Madison, 3pay, Tesco. Security testing is becoming more important than ever before.

As the world around us changes and we start to (sometimes unknowingly) put more information out there about ourselves. 

This task is just a starter to get a flavour of security testing. Again, it is probably one of those tasks that won't be just a day.

Your mission for today is:

* Check out some of the [Security testing resources](https://www.ministryoftesting.com/search?q=security) on The Ministry of Testing platform and see if it is something you would like to explore further. 
* Go and read some of [Troy Hunt](https://www.troyhunt.com/)'s work.
* Check out [OWASP](https://www.owasp.org/index.php/Main_Page) and the incredible resources they have.
* Check out the [30 Days of Security Testing](https://www.ministryoftesting.com/dojo/lessons/30-days-of-security-testing) challenge.

## (Task 27) Automation

Automation is a huge topic of debate and discussion within the software testing community. When you delve into this topic be prepared to hear such things like "automation fixes everything". Statements like this can lead to misconceptions and the misuse of automation. You may also read things about "[testing vs checking](http://www.satisfice.com/blog/archives/856)", please do not be put off by the language used, I know I found it overwhelming at the beginning. Richard Bradshaw gave an excellent TestBash talk about [automation in testing](https://www.ministryoftesting.com/dojo/lessons/automation-in-testing-richard-bradshaw), I highly recommend you start there. The Ministry of Testing platform also has a [Testing AMA](https://www.ministryoftesting.com/dojo/series/testing-ask-me-anything/lessons/ask-me-anything-richard-bradshaw-automation) on Automation with Richard where the community got to pose him questions and a [podcast](https://www.ministryoftesting.com/dojo/lessons/podcast-richard-bradshaw-test-automation) with him on how to get started with automation. Maybe there are more podcasts related to this topic that you stumbled across from 16.

One of the pros of automation is that it is a way to enhance the coverage you have of your application. You are only one person and you can miss things when re-checking of features, you are human. Computers can be very good at doing some things that people often fail at, Angie Jones wrote [a blog](http://angiejones.tech/adding-a-peripheral-view-to-test-automation/) about the things that can be missed by automation if it is scripted straight from a test case.

Focusing on [what to automate](https://club.ministryoftesting.com/t/what-to-automate/1310) is the most important part of automation. Setting that framing and adding in additional factors such as team goal, technology, time and team skills should assist you in identifying tools for your context. There are [many tools](https://www.ministryoftesting.com/dojo/lessons/automation-tools) out there and it can become overwhelming if you don’t set your framing.

If you want to give automation a try I recommend checking out the course from [Richard Bradshaw](https://www.ministryoftesting.com/dojo/series/selenium-webdriver-api-introduction-in-java-richard-bradshaw) or [Alan Richardson](https://www.seleniumsimplified.com/pages/getting-started/) to get you started. Of course, Selenium is not the only automation tool out there, but I have personally taken these two courses and can highly recommend them. Mark Winteringham also has a [three-part blog series](https://www.mwtestconsultancy.co.uk/automated-api-framework-part-1/) and [video course](https://www.ministryoftesting.com/dojo/series/let-s-build-an-api-checking-framework-mark-winteringham) about building an automated API test framework. Have you found any others? Did you find them useful? Why not share them with others in the [Automation thread](club.ministryoftesting.com/tag/automation) on The Club or the Automation channel on Slack.

Your Automation missions are:

* Start one of the automation courses recommended above. 
* Check out the [resources on Automation](https://www.ministryoftesting.com/search?q=automation) on the Ministry of Testing Platform.
* Explore the automation thread on [The Club](club.ministryoftesting.com/tag/automation).
* Bonus mission, try [30 Days of Automation in Testing](https://ministryoftesting.com/dojo/lessons/30-days-of-automation-in-testing) challenge!

## (Task 28) Performance testing

There are quite a collection of resources about [performance testing](https://www.ministryoftesting.com/dojo/lessons?topic=performance) on the Ministry of Testing platform, however, the [Quick Start Guide To Learning Performance Testing](https://www.ministryoftesting.com/dojo/lessons/a-quick-start-guide-to-learning-performance-testing) is a good place to start.

Think back to that app on your phone and the software package in work from Task 1. It is estimated that the average user loses patience with [a web page that doesn't load after 4 seconds](http://www.hobo-web.co.uk/your-website-design-should-load-in-4-seconds/). Now think about Black Friday sales or those concerts that sell out in 2 minutes. Have you ever been in an online queue for either of these? Load and performance testing can help the whole team to get an estimate of possible weakness in the product before it is released to customers.

In the [Performance Testing 101](https://www.ministryoftesting.com/dojo/series/performance-testing-101-simon-knight) online course on the Dojo, Simon Knight gives a useful breakdown of these terms in the [Performance Testing Patterns](https://www.ministryoftesting.com/dojo/lessons/variations-on-a-theme-performance-testing-patterns) lesson. I'll provide a brief summary here for context, but I recommend watching the course lesson for a more detailed explanation. I have left out Soak/Endurance, Stress, Spike and Capacity testing, which Simon covers in the video.

Performance testing aims to determine how responsive an application is under *normal* load conditions. Examples of questions that performance testing tries to answer are how long a transaction takes to complete or a page takes to load. It can help teams see if a site can handle the projected number of users. A performance test in a tool like Jmeter would keep the number of users at a normal level, where normal would be based on the requirements for the system.

Load testing is done to determine how the system responds under *heavy* load conditions. It would measure response times and resource utilisation under this heavy load. Load testing also helps to determine when the system breaks and if it is graceful when it does so. A question we may like answered when we do load testing would be how many transactions are we actually capable of dealing with when the system is under heavy load. When running a load test the level of users is kept high to get an idea of how the system will respond under the level of usage.

What to do next:

* Check out [PerfBytes](https://testingpodcast.com/category/perfbytes/) podcast.
* Read this [PerfBytes article](https://www.ministryoftesting.com/dojo/lessons/a-quick-start-guide-to-learning-performance-testing) on the Ministry of Testing Platform.
* Mark Tomlinson also featured on Test Talks with a [bucket full of bottlenecks](https://www.joecolantonio.com/testtalks/48-mark-tomlinson-performance-testing/).
* Take the [Performance Testing 101](https://www.ministryoftesting.com/dojo/series/performance-testing-101-simon-knight) course on the Ministry of Testing platform.
* Investigate the JMeter [User Manual](http://jmeter.apache.org/usermanual/).
* Bonus task, complete [30 Days of Performance Testing](https://ministryoftesting.com/dojo/lessons/30-days-of-performance-testing) challenge.

##  (Task 29) Ask a question

After all this information you probably have a lot of questions.

Ask a tester a question.

You can ask on Twitter, Slack, The Club or at a meetup. Expand the question into a discussion if you can. You never know what you might learn from it. This sounds like a simple topic for a whole task but it can be a daunting task for some. If you expand the question into a discussion it could continue on long past this one task.

If you need help with where to start with questions check out [TestSphere](https://twitter.com/TestSphere) on Twitter.

Steps to take to get started with asking questions and turning them into conversations and learning opportunities:

* Take a seemingly simple testing concept. Talk to someone about it. Ask for their understanding and explain your thoughts on the subject. Reflect on how your understanding differs from the other person's? Explore the differences.
* Did a blog or podcast cover the topic you have questions about? Leave a comment for the host to answer. 

## (Task 30) Share your experience

You can find inspiration and strength from writing about your experience, even if it is not for public consumption. Writing is a great form of self-retrospection or reflection and it allows you to learn from the past and to plan for the future. 

Think back to the first task you completed, why you were here, what you hoped to learn. Think about all the things that you have learned. Were any of the tasks particularly useful for you? If so, why? Did you find any uninteresting? You may be surprised at how useful others will find it if you share some of your experiences and findings.

How to share your experience:

* Tweet about each task with the #starttesting hashtag and feel free to tag [ministryoftest](https://twitter.com/ministryoftest).
* Post updates on Ministry of Testing Slack.
* Write blog posts of your learning journey.
* Write an email and send it to someone you may feel would benefit.
* Maybe even submit your own [99 second talk](https://www.ministryoftesting.com/dojo/lessons?topic=99-seconds) to the Ministry of Testing platform. 
* Share your findings on [The Club](https://club.ministryoftesting.com/).

---