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 Samantha 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 SBT Lite 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.

Medium Distance Relationship

Medium Distance Relationship is what my team and I named our contribution to Nordic Game Jam 2011.

Try the game, “Medium Distance Relationship”, here.

I came up with the interesting rolling control mechanism, which I experimented a bit on later in my prototype of a Rolling box control scheme – The Floor is Lava!.

The mechanic in MDR is simply to balance the distance to NPC agents running around after you. When they’re in your vicinity, you suck their life energy: good. If they are too close to you for too long, they die: bad.

The music was nicked from Kevin MacLeod at incompetech.com. Really awesome stuff for the likes of us.

Inglorious Skater, NGJ2010

Right now I am totally exhausted after having designed and coded in audio in the NGJ game Inglorious Skater.
There has been a lot of very interesting and funny games here at the Nordic flagship of IGDA’s Global Game Jam in Copenhagen.

There where a number of games submitted this year of which twelve went to through the first voting round:

  1. Disco Donkey Slaughterhouse
  2. Chasing Dots
  3. You Say Jump, I Say How High
  4. Grapple Grapple
  5. Shadow Ninja Monkey
  6. Find Love
  7. Preschool Theater Director
  8. Honeymoon

There where also four juror industry / research representatives that had to pick their favourites (one of them got picked twice, I think… correct me if I’m wrong)

Finally the People’s Award went to the game Only One Can Ride The Donkey.

The theme of the Global Game Jam was  deception and the local constraints for GMT+1 (based on timezones) was that the games had to incorporate the words monkey, donkey, or key (I’m afraid the art of subtlety has been lost; if I hear of a game including any of those within the next year, my head is going to pop).

I’ve noticed a few using XNA or GameMaker, a bit more using Flash but by far, the majority of the games here where created with Unity.