How To Give Constructive Feedback on User Stories

As a participant in an agile project I want to know how to give constructive feedback on User Stories so the team can continuously improve.

In many software development projects, the adoption of agile development principles has had a great start, but may be struggling when it comes to implementation. I’ve seen examples of that in the way features and requirements are broken down into programming tasks and further on into testing, deployment, and maintenance tasks. The best way to tie all these tasks together is to describe the end result as a User Story and reference the related tasks to that. That way, whoever does the related task will always have the expected end-result in mind and can without effort see what other tasks are planned for that story. As with many other things, starting can be difficult and may need a lot of collaboration so the best way to get started is to know how to give constructive feedback on User Stories.

  • What is a user story?
  • What is user story testability?
  • Who should advice and who should decide on the level of quality for a story?
  • What makes feedback constructive?

The goal with this article is to teach how to assess the quality of user stories and provide constructive feedback on their deficiencies.

What are user stories?

A user story is a simple way to describe a feature, its target audience, and its merits in a single sentence. It is basically requirement specification in agile projects.

The most common form is the following:

As a [role],
I can [feature]
so that [reason]

Keep it broad in the backlog, specify and add detail when starting the sprint.

Add acceptance criteria.

Scenario [#]
Given [context]
When [event]
Then [outcome]

The team should agree on the criteria of a good user story. If a story does not meet the criteria, simply ask yourself: “what is missing”, raise your concern and your preliminary answer with the team – even if your answer is so simple that you are almost embarrassed to say it out loud.

How To Give Constructive feedback on User Stories

The team and yourself may not agree to the solution, but that’s okay.

The key is that you share your concern in a concise way and show the way to a solution by communicating a possible solution to the team.

Maybe your answer is really good and it solves the issue with the user story. Great, now move on. Your solution may also be really shitty and you will be the laughing stock of the entire mainframe developer department just for raising the issue. Also great!, they are not part of the team that you trust and you know that you simply suggested the solution in lack of a perfect solution to start a collaborative discussion on how to solve the problem.

The idea here is that the culture in your team has to support even the most shitty suggestions because they can start deep conversations that may lead to genius solutions.

Trust yourself and your team, lead the way to the solution, and know that your solution may not be the best.

Leave a comment: describe pitfalls when creating user stories and how to give constructive feedback in agile teams.

Check out this great related article.

Certified Agile Tester Course Outline – my summery of the CAT course

I recently became a Certified Agile Tester and I just came across my notes from the course and wanted to share my personal experience with it in case you are interested in the course but would like some details more about it before signing up. Fortunately some of my colleagues could give me some details before I started the course, but I might be more lucky than most. ISQI are not super informative about the course content, so here you go: my summary of the CAT course – the Certified Agile Tester Course Outline. Enjoy :)

If you have any questions or comments, do not hesitate to comment below or contact me.

My CAT course consisted of 4 days of training and one exam day with two tests. Each of the four days of the Certified Agile Tester course have a theme: Day 1: Agile Methods and Process, Day 2: Planning, Day 3: Testing, Day 4: Teams. I’ve organised the article in sections describing each of the training days. The exam day is a tale of its own, so I might write about the another time.

Day 1 – Agile Methods and Process

The first day is about the Agile Methods and Process. These are covered by the modules 1 and 2 in the CAT Manual 3.0.

  • Introduction
  • Daily Scrum
  • Problems with Traditional
  • Agile Manifesto & Principles
  • Agile Methods
  • Agile Process Option
  • Roles
  • Intro to Agile Exercise

We started the course getting introduced to the instructor Søren Wassard. After that, we got a short task to write our own User Story which we all put up on a Task Board that we used for a Daily Scrum every morning during the course. We talked about the concept of the daily scrum although all of us knew it. Later, as we discussed the variety of uses of the task board, some of us shared our experiences which proved to be very different.

One of the things that the student is evaluated on is the Soft skills, which the instructor is evaluating during the training period.

A rather negative topic is the constant comparison to traditional software development methods like Waterfall and the V-model. In the manual there is an emphasis on the problems with traditional methods

We were introduced to the most commonly used Agile methods: Scrum, Kanban, XP, and Lean Software development. The Agile process option that is used for examples in the course is briefly defined, and referenced the rest of the course. Within the process, the necessary roles are defined.

We ended the day with a practical group exercise in which we had to build small town in Lego bricks using the knowledge about agile that we had acquired during the day.

Of course there was some homework as well, which was 5 rather easy K2 questions. I re-read the part of the manual that we’d gone through during the day, taking notes and highlighted some of the key points from the lectures. Finally I skimmed the modules 4, 5, and 6 really quick before passing out.

Day 2 – Planning

The theme of Day 2 was Planning and the topics included in the modules 4 and 5 that describes the strategic aspects of agile testing.

  • Requirements & Specifications
  • Iteration Zero
  • Release Planning
  • Task Board
  • Test Strategy
  • Estimation
  • Iteration Planning
  • Burn-down Charts
  • Sprint Practice Exercises

That covers the topics of Module 4 and 5 which are about pre-planning and continuous planning respectively.

The pre-planning theme in Module 4 include topics mostly on Requirements and Specifications that should be addressed before the team start continuously delivering features.

Iteration Zero is the framing in which the team can get to know each other, do the initial Release Planning, deciding on how to use a Task Board. The  team can outline the Test Strategy, and do the initial Estimation on what stories and tasks that might already be specified.

Module 5 focuses more on the continuous planning that is repeated and improved between each sprint. include the topics:

Iteration Planning that is done at the very beginning of each sprint, sprint reviews and retrospectives are used to evaluate the latest iteration for improvement in the following iterations. Burn-down Charts on both the release and iteration levels that are used throughout the project as an indicator on how it is going.

Building on the Lego exercise from Day 1, the Sprint Practice Exercises was now run as they would be on the exam day, although we were collaborating on the exercises.

The homework on Day 2 was very similar to those from Day 1 with a handful K2 questions with answers and marking guidelines.

Day 3 – Testing

Day 3 had more technical topics than the other days. It focuses on the practical aspects of being an agile tester in the module 6 and most of module 7. We did the last part of module 7, about Test Automation and Technical and Testing Debt on day 4.

  • Continuous Integration
  • Version Management
  • Pairing
  • Acceptance Criteria
  • Regression Testing
  • Defect Management

We talked about the very practical techniques of Continuous Integration and Version Management. These should be a default tool for anyone in the team.

Another practical technique we discussed was Pairing – the concept of working on tasks in pairs. Basically the discussion was about when to pair and not to pair. In general, the message was that any combination of team roles can benefit from pairing.

One of the greater topics of the day was Acceptance Criteria in relation to the Definition of Done and Acceptance Testing. In extension to these, we talked about which basic Test Techniques are useful to apply to different situations. Various test techniques can be applied both when planning the user stories’ acceptance criteria and while conducting exploratory tests.

We talked about the how Agile methods strongly advocate automating regression testing given the continuous integration and deliveries that is a core part of the methods.

Defect management in Agile projects is different from that in traditional projects because often the defects are fixed almost immediately after they are found.

The practical exercises continued from day 2 in the same manner where we worked in two teams of 4 persons. On day 2 it was stressful doing the exercises because we didn’t know exactly what to do, but on day 3 it was much easier because we tried it the day before.

The homework consisted of only two K2 example questions. In addition there was one scenario based question with 4 specific questions.

Day 4 – Teams

On day 4, the main theme was Agile Teams in different contexts, with module 9 in mind. Additionally, several more technical topics were covered in the last part of module 7 and module 8. Finally the course was summarised with module 10 and the last preparing questions for the exam was reviewed.

  • Test Automation
  • Non Functional Testing
  • Tools Support
  • Debt Technical & Testing
  • TDD
  • Teams
  • Agile For Large Projects
  • Course Summary

We started the day with the last part of module 7 about Test Automation, Non Functional Testing, Tools Support, and Technical & Testing Debt.  With regards to Test Automation, the CAT manual mostly covered  the why and what but as part of the course, we discussed how automation is implemented in some of the participants’ companies.  In a similar manner, the why and what of non-functional testing was briefly reviewed and we discussed what techniques can be used for testing non-functional requirements.

Different types of tools that can support the many shared roles and their activities in Agile Projects. We talked about the pros and cons when using open source and commercial tools.

Agile theory and practitioners often talk about Technical Debt where Testing Debt is a less covered topic. We reviewed and discussed how to manage Testing Debt. The same way that Debt is discussed extensively in relation to technical issues, TDD is often centred around programming where, as the name suggest, it is test design before programming. The main message was that test professionals have a lot to contribute with in TDD.

Team structures are unique and should be handled that way practically. That said, we discussed some common patterns that Agile Teams form. We covered distributed and co-located teams and what tools can support distributed teams. We also talked about how the soft skills can benefit how well teams perform.

Although Agile methods are very common in small teams and start-up companies, certifications as the CAT are often an answer to the needs from larger companies and enterprises. That makes Agile for Large Projects and Enterprise Projects obvious and very relevant topics for the course.

The final practical exercise consisted of two parts (check out the article about the practical exam and exercises). The first part was done in the same groups as the previous days. The second part was done individually to prepare us for the exam conditions.

Conclusion

Concluding the course we reviewed each module briefly in a Q&A where the instructor asked questions about them and we, the participants answered them.

I hope you can use my Certified Agile Tester Course Outline. Please leave a comment if anything was unclear. Then I’ll try to answer as best as I can

:)

How to deliver test statuses at a daily scrum

As an agile tester, I want to share the status of the project’s testing tasks with my team, so we can solve any issues and impediments before they become bottle necks.

This article will give you an idea of how to deliver test statuses at a daily scrum. The test related work in agile teams seems to revolve around user stories and their acceptance criteria. This will naturally also be the centre of the discussions in daily standup meetings (or a scrum as it is often called).

Here are some of the basic question that I will address in this article:

  • What is the basic agenda of a stand-up meeting?
  • Which testing activities should an agile tester be planning for an iteration?
  • What testing constraints should an agile tester be prepared to meet?
  • What obstacles impacting testing should an agile tester be prepared to address?
  • What to consider when communicating in cross-functional teams
  • The beauty of Failing Fast and sharing it based on trust and shared responsibility

How To Deliver Test Statuses at Daily Scrums so Everyone can Understand It

One of the rules of the scrum is that it is time-boxed, so you don’t get to chit-chat – you have to be concise. Another scrum rule is that each and all members deliver a status including obstacles and next steps within the time-box. It is pretty much like a turn-based game where each player go through the turn’s phases:

  1. what was your tasks since last scrum
  2. what are your tasks until next scrum
  3. what may prevent you from accomplishing them

A case: You’ve been working with a coder on a user story for an email opt-in form on a website:

“As a non-subscriber,
I can submit my email on a landing page,
so I can receive updates through the email marketing channel”

You’ve established the acceptance criteria and the need to do an exploratory test that include an integration to an email marketing provider, but you don’t have the customer’s credentials for the service so you can setup a test environment for the integration. You’ve already collaborated with the coder on the tests and there is a stub that can receive the email.

This is how you’d give your team the status update:

“Yesterday, Coder Bob an I tested the story for the email opt-in form on the landing page with a stub.
Next step is to test that the integration to the email marketing provider actually works.
However, I need the credentials to the email marketing service so I can setup an email-list that can catch the output from the form”

To that, the product owner would naturally answer:

“Sure, I’ll get it for you after the meeting”

There: three breaths of air and everyone on the team knows exactly what you did, what you’re about to, and what holds you back from doing it. You even got a solution to your problem in less than 30 seconds. (I should add that the example story is pretty short and there would be more of the same kind in your status update. Problems of this size could also be solved outside the standup meeting, but for the sake of the example and me not being able to come up with a real problem, please play along here).

In the case, you clearly state your task since last stand-up meeting, your next step, and the obstacle you’re facing. A team member have the solution to your problem and it is clear what has to be done and who will take the next step.

However, what if not all team members know what you’re talking about, even if you speak no riddles?

In agile teams all members have different skill sets, which is good. It is therefore important, not only to be concise but to also provide enough information about an obstacle so everyone can understand it and potentially help you clear the obstacle.

It is a two-way street: if you find yourself in a scrum not understanding a fellow team member’s problems it is your job to ask for just enough details to understand the problem. Don’t babble on or encourage the speaker to do so. Simply raise your hand and ask concisely. To riff on the example, you might not know what an email-list is in the context of email marketing providers. Ask: “What is an email-list”. Everyone at the scrum will know the context of the question and know that you ask because you might have a great solution to the problem if you know more about it.

Fear of inadequacy might withhold some people from asking that “dumb” question. Fear of inadequacy and “dumb” questions simply does not exist in pure collaborative work. You’re already a team member, so you’ve probably been chosen for a unique skill set that fill the gaps of other team members – perhaps even your ability to ask questions in a way that reveal unforeseen issues, in which case it is your duty to practise that skill until success.

  • Be concise.
  • State what you did,
  • what you’re about to,
  • and what may hold you back.
  • If in doubt, ask
  • and ask again.

What is your take on how to deliver test statuses at a daily scrum? Do you share similar experiences or is there a side to it that you think is important? Leave a comment and let me know.

Can metrics improve agile testing? Measure, Analyse, Adjust

As a tester in an agile project, I want to make visible how I spend my time, so my team can act accordingly and stakeholders know what to expect.

As you’ve probably experienced, plans and estimates are revised during a sprint. I have never heard of any healthy project that has not done that. In an unhealthy project, stakeholders may stick to a loosely estimated initial plan because they do not know better and cannot act on any historic data

Consider a scenario with a release date getting closer. A stakeholder, who is restrained by a contractual budget and a promise of timely releases, asks the team when they are done testing the stories. The team can’t answer with any acceptable margin, so the stakeholder start drilling down into the stories asking specific questions about how many hours are needed for exploratory testing, test design, and GUI automation – basically taking over the test strategy. At the end of the meeting the testers have committed to some arbitrary forced number of hours for each type of testing on the remaining user stories. The only benefit of that is that the stakeholder is satisfied until it is discovered that none of the new estimates are useful at the next status meeting.

In this article I provide an answer to the question: Can metrics improve agile testing. The best way to answer that is to split it into these four sub topics which I will answer in sequence:

  • Why collecting metrics is helpful
  • What metrics should be gathered during a sprint?
  • What is the easiest way to gather metrics during a sprint?
  • How can metrics help improve testing?

Everyone must know why they are collecting metrics

Imagine recording data without knowing what it is used for and why it is gathered in the first place. The first thing I could imagine myself doing was – consciously or unconsciously – making up reasons. Adding to that, I would become insecure if the metrics are in any way connected to my performance on the team. Building on that and the uncertain reasons behind the metrics, some might even alter those in a direction that would be of no benefit to anyone.

Say, for example, that you are recording how much time you spend on testing a story. You have no idea what the data is used for. You want yourself and the project to look good in the statistics, so you start rounding the numbers down here and there – just a tad. Over the duration of the sprint, that become several hours. Then it is time for stacking the backlog for the next sprint and guess what more stories are taken in than you and your team can test within the sprint.

So be transparent about why and how metrics are gathered. Be vocal about why you measure any performance on the team and project. If you are in any doubt of why you are collecting a metric, ask about it and discuss what it can be used for and how it can benefit the project.

What metrics should be gathered during a sprint?

In other words: What does testers spend their time on? The answer is in my experience always some version of these three things:

  • Testing (including running tests against the application under test)
  • Investigating, reporting, and re-testing bugs (including collaborating with coders and product owners)
  • Setting up and waiting for environments or other resources such as test data (including designing scripted test cases based on notes from previous ET-sessions)

One of the most efficient test techniques in agile testing is exploratory testing because there is less preparation and setup required compared to scripted tests. It is not always easy to gather metrics while focussing your energy on finding creative ways to test the system, so you will need a simple system for doing so.

What is the easiest way to gather metrics during a sprint?

One such system I’ve been using for gathering metrics during exploratory testing sessions is a light version of session-based test management or SBTM, which was developed by Jon and James Bach. The core idea is simply to take notes of what you are doing during a time boxed session and mark each entry. The notes have to really simple so it does not take up all your creative testing energy.

The wikipedia entry defines session based testing like so:

Session-based testing is a software test method that aims to combine accountability and exploratory testing to provide rapid defect discovery, creative on-the-fly test design, management control and metrics reporting. wikipedia.org/wiki/Session-based_testing

A genius of the tool is that you will take specific note of how much time you use on
1) Testing, 2) investigating Bugs, and 3) Set up. These are also called TBS Metrics. When you gather the metrics, you can see where you spend your time, so if you see less time testing than investigating bugs or even setting up the environment, you can take action on for example getting the environment setup automated. If e.g. you spend a lot of time investigating bugs, perhaps the programmers should be more involved in testing or the user stories should be analysed with the product owner to get more specific acceptance criteria.

The important point is that if you collect these 3 simple TBS metrics, you have come a long way towards being able to analyse your results, you can continuously improve your testing effort based on those numbers.

The full SBTM may be a big bite to start off with, so I recommend that you start with SBT Lite which was defined by my mentor Sam Kalman who worked with Jon Bach at Quardev. SBT Lite is much more free-form, but is still able capture the metrics you need.

In practise, a tester would take notes on his/her actions during an exploratory test session.
Before the session starts, a session charter is chosen and noted on the session sheet along with the esters name. The charter could be one of the acceptance criteria in a user story or an entire user story depending on the size and scope of them. A meta session charter could also be to come up with session charters for a set of stories. The charter is basically the mission of the session.

During the session, the tester marks his/her notes as T, B, or S, along with a time-stamp and a one-line description of what happened. The result should look much like a commit log from healthy pair programming session.

When analysing the session logs, it would be evident how much time is used on testing, bug, or setup time respectively. In the full SBTM resource there is a link to Perl tool that can analyse session notes if they are formatted in a specific way, but you should make your own session log parser if you prefer to follow the simpler version or even design your own set of metrics (which I recommend once you’ve tried this for a few sessions).

How can metrics help improve testing?

As I suggested in the scenario in the introduction, it is not only managers and stakeholders that benefit from the collected metrics. Testers can benefit on a personal (professional) level, the team can benefit, if there is a cross-team test organisation that too can benefit from the TBS metrics.

The individual can use the analysis of the metrics to hone his/her skills. Perhaps compare how much time is spent on each task type compared to other testers. If the numbers differ significantly, have a conversation about why. Maybe you can find new ways to be more efficient or maybe you have some important advice for one of your colleagues.

The team can use the analysis to find bottle necks. E.g. if a lot of time is spent on setup, perhaps the testers need a dedicated test environment that is hooked up to the CI-server or if that is already the case, perhaps it should not re-deploy every time there is a push to the development branch.

So, can metrics improve agile testing?

Yes, if you start measuring right now!

My final recommendation regarding metrics is simply to start collecting data immediately.

Start simple by introducing a simplified version of Session Based Test Management to your testing colleagues on your team – talk to them about it and discuss how your team might benefit. Next, present the idea to the rest of your team and get some feedback on how simple it should be if everyone should be able to use it.

Now, collect some data, analyse it, present the results, and adjust.

Leave a comment about how you use metrics in your organisation and let me know if this helps you in any way.

Resources

Here’s a list of the tools you can use to look more into session-based test management an starting a simple measurement of your team’s testing effort:

How to Plan and Document Testing in Agile Projects

As a tester in an agile software development project, I want to plan and document exploratory tests, so I can prove test results to customers and easily re-run the tests for re-testing and regression testing. This article is made to answer the question of how to plan and document testing in agile projects.

The problems are that time is spent documenting tests that are only used once or that the tests are only run by the same person, so the documentation is never actually read. Other times, the test documentation needs to be handed off to another person that need to run the tests. In the latter situations, the person getting the documentation rarely have time to read the documentation or the required background knowledge to understand it thoroughly without talking to the author anyway.

To solve these problems you should optimise processes within and around your team. Here are some basics that your team need:

  • Reliable infrastructure that supports testing
  • A shared understanding of basic test techniques
  • Thorough user story design with the core team
  • Work in pairs to spread knowledge and prevent silos
  • Structure manual testing in a simple framework
  • Automate regression tests of business critical features

Reliable infrastructure that supports testing

No experienced tester that I have met have not tried to sit and wait for a test environment to be ready or their test data has been corrupted. The problem is that often there are a limited amount of environments or some service or database that the environment depends upon is unstable or not working as expected, so the test cannot be completed.

Building and maintaining a reliable infrastructure for testing can involve many tiny factors that are easy to solve but just as easy to break if unaware of them.

Some of the solutions to these problems are so simple that it is unbelievable that the problems ever existed, but that is easy to say when looking back at them.

Use a dedicated server for testing

In some projects, there are no rule or framework for how servers, database connections, and services are versioned and how they are integrated. Perhaps the team has a few dedicated servers for each phase in the application life cycle

Talk to your team about configuration management and start by naming the environments and make up rules for how they can integrate so no-one accidentally wipes your test environment when you are almost done with the long regression test.

Keep a one-to-one ratio between application and databases

When several application instances are using the same database instance you are begging for trouble. When a change is made to the application in one environment that involves updating the database schema, naturally all of the dependent application instances needs to get that code change as well. The simple solution is to have a one-to-one relation between app-instances and db-instances. Never let more than one code branch use the same database.

Organise test data

When several people are using the same database for testing, say one is automating regression testing and another is running exploratory testing on some new feature, make sure to avoid each other in the database. That means that you need to talk to each other about what data you need to manipulate. If that is unclear or if you are not sure if each other’s data will be affected by proxy, branch out, make a copy of the database and use separate environments. Otherwise you cannot trust your tests anyway.

If part of the requirements are to support loading data from an external service and furthermore serving your data along with that, make sure to validate the integrity of the data from the external source before updating your database with it. If that have already happened, talk to your customer about how to use the external source without breaking your system.

Mock or stub external integrations

Unavailable and unstable integrations in a test environment can be the source of a lot of unwanted noise.

If you are in the unfortunate situation to depend on an external service, make sure to mock it off or virtualise it if you must. That way you have complete control of how it performs. There is not many things worse than being benched because some external resource is performing badly.

A shared understanding of basic test techniques

A common pitfall when available test resources are limited when the deadline approaches, is to get free hands on the team to test without them knowing how to apply test techniques in practise. Some ways to circumvent this is to share knowledge about test techniques within the team, send team members off on courses in practical use of basic test techniques, and/or take on agile coaches or test mentors that can help the team learn some test techniques.

Another idea is to make a book club on the team, where each team member will read a book and present the key points to the rest of the team followed by a discussion that will produce a practical action plan for implementation of at least one idea from the book. Ideally the book club should not be limited to literature about testing, but to anything relevant to the team.

Build a shared reference

Build a library of simplified pattern-descriptions of most test techniques so your team can easily use them in appropriate situations. A place to find relevant information about test techniques is in some of the popular test certification programs, e.g. ISTQB Advanced Test Analyst Syllabus 2012 has a list of some basic techniques that can be used in practise. The following list is taken from the learning objectives list from the chapter on testing techniques. As a tester on your team, you should understand each of them and pick a few that you want to teach your colleagues:

Specification-Based Techniques

Defect-Based Techniques

Experience-Based Techniques

Thorough user story design with the core team

Design user stories together. In software development there are always three very different views on user stories, the customer’s, the coder’s, and the tester’s. An agile practice, called The Three Amigos has been defined in order to describe this fact, how to acknowledge it, and use it as an advantage to design better user stories.

The basics of the practice is that the product owner/business analyst, a coder, and a tester get the joint responsibility to make user stories are ready for implementation and testing according to the customer’s needs. A clever book is written about this: Lean-Agile Acceptance Test-Driven Development: Better Software Through Collaboration

Work in pairs to spread knowledge and prevent silos

Face-to-face interaction is by far the best way to share knowledge. This is even more true when sharing a technique for accomplishing a complex task such as testing an application or teaching someone a business subject matter that might not make sense.

With testing in focus, all team members can benefit from pair-testing. The testers’ mindset can be shared with the other roles on the team so they can build in quality in their respective areas of responsibility on the project. These are some of the benefits that the team roles can draw from pair-testing:

Tester/tester

Each tester in the pair can learn details in test techniques from the other tester.

More details are discovered and there are generated ideas on two levels while testing because one tester drives and the other navigates.

If the navigator take session notes, the driver has free hands to follow the flow of digging out a bug from a complex string of actions.

If the driver discovers an unexpected behaviour, the navigator can easier retrace the steps to reproduce the issue.

Product owner/tester

The tester can pickup som of the business processes that might not make sense if not working with them directly with a product owner.

The product owner can learn some structures and techniques around testing that enables him/her to take over some of the testing tasks when time is limited.

The tester contribute with the tester’s mindset when identifying acceptance criteria to a user story, so these will be more detailed and accurate when the coder starts implementing them and when the tester later need to remember what details matter the most in the story.

Coder/tester

The coder can explain some of the logic behind the implementations in the application so the tester can see what areas, modules, or combinations might make more sense to test than others.

The tester can show some of the techniques s/he uses when running a functional test, so the coder can use some of the same techniques when writing unit tests.

The coder can teach the tester about how to structure the architecture behind the automation framework.

Coder/coder, product owner/coder, and product owner/product owner

The last three combinations will also bring a lot of value to the product or project in relation to other tasks than testing.

The coder/coder pairs will produce high-quality code with built-in code review and, if done right, full unit test coverage for regression testing in the CI-system.

The product owner/coder pair will take form as deep discussions into the minute details about the business logic, so the product owner will write more effective acceptance criteria, and the coder will understand more of the undocumented details about the business.

The product owner/product owner pair is rarely done in practice, but the effect of the combination is that the user stories will be more elaborate and accurate.

Structure manual testing in a simple framework

Use light-weight documentation. Once the user stories are ready for implementation and testing according to the customer’s needs som might think that documentation is sufficient. Ideally, yes. In reality, no: details are found during implementation and testing and naturally the decisions around those need to be added to the user story. These might be elaborations around a newly discovered acceptance criteria or an error that occur as a result of the implementation. In relation to testing, add documentation will be descriptions of how various testing techniques would cover the acceptance criteria in the story.

If using an issue tracking system like Jira to track user stories, I recommend simply adding new information to and grooming existing info in the user story until it is done.

Specific to exploratory testing, a useful tool is Session Based Test Management (SBTM) or SBTLite, where the tester will note what the time is spent on while doing exploratory test sessions.

Automate regression tests of business critical features

Regression and re-tests are some of the most time-wasting activities in software development. Mostly because it does not need creative problem solving skills, just mere monkey–see–monkey–do skills. Automate functional tests that you don’t want to repeat ever again.

Think automation from the beginning of the project. Sometimes a considered framework may be very hard to automate. A common problem in UI automation is some UI frameworks’ use of dynamic element identifiers. That makes it hard to write and maintain a good element locator.

Re-testing of all defects that are found

When a defect is found, the test for it will be re-run several times, first by the coder while fixing it, then by the tester that found it. It is a waste of time if the exact same test is run manually again and again. If the tester can automate the re-test of the defect as it is found, it will be a great service to the coder that fixes it. This does not mean that the coder does not have to write unit tests around the fix.

Regression tests that touch high-value business flows in the application

Regression tests are indispensable. That is especially true when a development team is using a VCS with several branches and integrating them often in an agile project. If you manage your automation right, you can make the time spent on manual regression test count. After all, it is with manual testing that the really nasty bugs are found.

Follow the money when writing automated tests. If your customer is always sure to stay in business when you deliver your software, they can pay you. In release-, sprint planning and backlog grooming, there should be made conscious decisions about what is the most important and high value user stories. When automating regression tests, make sure to have a good test coverage of these stories.

Validate integrations that may break during development

You always want to know the state of your own code and that can be delimited by knowing the state of any integrations that affect your system. If an external service is down and one of your features depends on it you have the chance to mock it or virtualise it if it needs more intelligent features than what a mock can provide.

Start criteria for any manual testing should be known

Before giving any human a test related task you should know the basic state of the system. It is very annoying to manually test a long flow only to find out that some depending configuration is not setup correctly and you have to start all over.

Simplify Game Development: Think of it as a Toy

The Toy is built through iterations of development, play and tweak using the technology that will be used to build the final game.

One of the basic and most important components of a computer game is how the player interacts with the game. Many games rely on characters or objects that are controlled by the player. Very few players are consciously aware of this interaction and this is often the way it should be if the engagement in the game should be maintained. Therefore the feel of the game should be a central part of the game and iterated upon throughout the production.

This is the second in a series of articles on how to simplify game development based on my master thesis on game production. I hope that game developers will be able to simplify game production with these ideas in mind.

I will not go into details about what the definition of a toy other than it is something that you can play with. There are certain similarities to game development that I find interesting: Toys are made for play, which is an essential part of most games. Toys can be played with for hours at a time. Toys are mere tools for play and immersion – suspension of disbelief. Likewise will people probably play your games as much as possible if the toy their tool of choice when it comes to play. This is why it is important to perfect the toy.

I read in a book about game feel that Shigeru Miyamoto, the creator of Super Mario, spent a lot of time iterating over the Super Mario 64 controls in what he referred to as a “garden” – a virtual test environment containing elements of the game that have an impact on the feel. I am sure that iteration on controls is time well spent. I myself will not play a game for long if the controls are annoying.

I am currently in the process of porting a prototype to tablets where the controls are giving me a hard time. The initial prototype was made for 2-4 players using keyboards or joypads for input and was a thrill chasing each other around in a maze with different speed and drag attributes. At some point we decided that the game format would be better for 2 players on a tablet where each player had to control their character with touch input. The entire feel that we worked hard to achieve was lost. It was a brilliant idea to use the tablet for the immediate face-to-face interaction between the players, but the controls could not be ported directly. Mainly because we had spent some time tweaking the controls to the natural haptic feedback that the joypads and keyboard give, where a touch screen with a rendered image of a joystick is nothing like it.

Thinking of your game as a toy is one of the fundamental things you can do for your game design. If the toy is not fun to play with, why would anyone ever play a game? Start early playing with the toy, make sure it is fun, discard unnecessary features, hone what makes you want to keep playing it. Above all, get other people to play with the toy and tell why they want to keep playing and what has no significance.

Simplify Game Development: Share a Simple Concept Early

Define a clear concept along with the level of quality that you want the game has to have for narrative, game and play.

There are many ways to get ideas. These range from getting a revelation while walking down the street or doing the dishes, to working structured with tools and methods in collaborative sessions. I like to capture as many ideas, tell as many people about them as possible, and formulate the ideas so your peers can easily understand them.

This is the first in a series of articles on how to simplify game development based on my master thesis on game production. I hope that game developers will be able to simplify game production with these ideas in mind.

Share the Concept Early and Often

Any notion can be made into a game, but the hard part is to conceptualize and develop the idea. Initially the idea don’t need to be formulated more than enough to remember it. However, if I leave my ideas too long in the notebook, I tend to forget what the essence of them was. So it is a good idea to soon start to collaborate with other people on the ideas, start formulating it and specify the little details that make the idea appealing and different from other ideas.

In my experience it is important to share the concept – the sooner the better. Some people are afraid of others “stealing” their idea, but in my world an idea cannot be stolen. It cannot be owned until there have been put work into it. I.e. time to develop the idea into something more than thoughts and words on a paper. An idea is a free entity until it has become a concept in the sense that it has been formalized and captured in a form that specify it enough to be differentiated from finished products. Anyway this is an issue for lawyers – not me, and the benefit from sharing an idea is far more worth than the work it takes to “steal” an idea. I guess the point is that execution is what gives value to the concept.

Set Boundaries for Your Game Concept

Once you have started collaborating your idea with others, you should start elaborating the little details makes it appealing. This is where catch phrases as KISS (Keep It Simple Stupid), “less is more”, etc., can be used actively to test the quality of the idea. There is a reason that these phrases are so popular. The exercise is to start simple, by formulating the idea with as few words as possible – in Reality Lag, we use a for we call Power Docs which has a simple and strict form for capturing an idea. The limit is one page describing the idea and it has to be playable in the mind of the reader.

Test the Concept With Players

Test the idea! Ask people if they would play the game. They may ask about or add to the idea, which is golden. Elaborate on your idea, draw the idea, build a simple prototype. If the idea is dependent on a story, write a simple plot outline, describe a part of the world and a few of the characters or their relation. Then test the idea again. Expose it to your peers and see if they get your point, think it is interesting etc. The goal is to get feedback.

The next is to start developing the toy and narrative of the game.

Simplify Game Development

I has been some time since I reflected closer on ways to simplify game development. This article is the kickstart to set of articles on my views on it. Since my graduation I’ve seen different software productions, mainly from a quality- and process oriented perspective. I’ve also experimented with different game development processes in smaller teams. This experience has given me some new takes on some of the initial ideas that I studied at the university.

The main idea with these articles on game production is to review the core topics of my master thesis on game production. I hope that with these ideas in mind game developers will be able to simplify game production.

First of all, I see these seven topics as the most important in game productions:

Each of the above topics are still the way I like to simplify game production and perhaps even any software production. The topics should not be seen as phases in a production but rather as elements that are iterated upon throughout the entire development of the game. At some point each of the topics will reach a mature state and more effort can be put into the other areas.

As I release the articles on the topics, I will add links to them in this article. Thus is this article better seen as an index or teaser to the following seven articles in this series.

Why are in-game tutorials important to some and not to other video games?

These are some of the questions about in-game tutorials that have always nagged me: Why are in-game tutorials important to some and not to other video games? How can in-game tutorials be made seamless to avoid breaking the player’s suspension of disbelief in a video game? When does a game need an in-game tutorial? Should the player learn the game by failing? What kinds of players will put up with the frustration of not being tutored? Which games can do without tutorials? What different types of in-game tutorials are there? How can in-game tutorials be made interesting and seem like an integrated part of the game?

In a way, there are three types of video games: the illogical, the intuitive, and those with in-game tutorials. The illogical game probably has the hardest time settling with the players. The intuitive game is a bit better off once the player knows what to do and where to go. Those with in-game tutorials give the player a head start in complex concepts. However, there is a fine balance to keep: do not underestimate and patronize your players. I have an opinion on some of the strengths and weaknesses that should be considered when talking about in-game tutorials.

Each of the types, illogical, intuitive, and with _in-game tutorial _are of course mixed and graduated in reality, but for the sake of the discussion, I’ve taken them to the extreme.

The Illogical Games

In these types of games, the controls are often hard to learn and the objectives in the game often don’t make sense unless the player knows about the game world. The controls and objectives doesn’t necessarily make sense even when they are learned. The games must be interesting for players before they learn the controls and objectives.

Games with illogical controls or objectives often have a steep learning curve. Some may categorize these as hardcore games. I remember sitting in front of my brother’s Amiga 500 immersed in a variety of games with great enthusiasm, but often after having been frustrated by having to figure out the controls by trial and error.

Practically no games were translated to our mother tongue and if they were, we wouldn’t waste precious gaming time reading the tome that came with the game. That meant that a hard judgement fell on the illogical games: discarded! (i.e. because the games simply fell outside of our zone) So, what made us grant the games our attention back then, was most likely the scarcity of videogames in general.

If games was as ubiquitous as they are today, I think that we’d been more demanding and the most illogical would not be granted a second.

The Intuitive Games

Intuitive game controls and objectives are easy to learn may not need to be taught to the player. Controls and objectives make sense the first time you’re learning them. The games does not rely on being overly interesting for players to learn to play. Intuitive games have a gradual learning curve. Some may categorize them as casual games. Some controls are so obvious and easy to learn that it does not really require much effort from the designer nor the user. Just play the game. However, varying complexity in games are often reflected in the controls and how the objectives of the games are given to the player.

Consider a player that has never played a first person shooter. To him, Doom is something that awaits and not one of the founding fathers of what evolved into a standard control scheme in subsequent 3d shooters.
This player need an incentive to play the game and learn the controls. Back in the day, it was fancy photorealism in VGA and the compelling story about… killing monsters. And that was more than enough for most of us. Frankly, I do not recall if the controls were taught in-game or only in the manual – some of the controls wasn’t event in the manual.

The point is that to the player that never played with these controls, they would not be illogical after some time getting used to them, perhaps even intuitive if using the wasd/mouse configuration that is pretty much standard these days.

The Games with In-Game Tutorials

Even though I named this the third type of game, it serves more like a transcendent category: In-game tutorials are both used in illogical and intuitive games because both may benefit from in-game tutorials or in some cases in-game tutorials are a disadvantage for the intentions of a game. First of all, in-game tutorials lets the players learn the controls and objectives fast and really get into the intended game play sooner. The downside is that there is a risk of patronizing the player if the controls are super intuitive  and still spelled out, so I guess there is a fine balance to keep depending on the players:

  1. Continuous throughout the game,
  2. once per game session, or
  3. once per player (stored in a user profile or the like).

In the end, remember that videogames are mostly entertainment and if the player ends up frustrated, the game fails its purpose.

Rolling box control scheme – The Floor is Lava!

Click the image to try the game.
I prototyped this simple physics based rolling box control scheme using Unity, in only a few hours.
To move the box, you add torque to roll it by pressing the arrow keys or swiping the screen (so far only android devices).
Try to keep the box on the floats and get to the safe platform. If you hit the floor, you’ll lose life.
It feels a bit heavy at first, but it might grow on you with a few other interesting game design dimensions.
Like the controls in Edge, I like the constraints to the three dimensions that it has – not to mention the bonus you’ll get for balancing the box on the edges.
Try out the rolling box control scheme and give me some feedback on it.