Tag: Learning

Expressing Expectations

Experiment Feedback Learning Pattern Testing No Comments

Long long ago, while preparing experiments for my diploma thesis in physics, my tutor taught me to express my expectation of the outcome of experiments before actually running them. I was to not only to express them in my head, but speak them out loudly, may be even make a note.

This helped a lot, when figuring out where my thinking didn’t match the experimental evidence. There was no denying when my expectation differed from the empirical result. Typically, there were two sources for the differences:

  1. My mental model wasn’t good enough to match the result of an experiment.
  2. The experimental setup wasn’t designed well enough to show the effect I was trying to measure.

I find that this is still working well in software development (both the coding part as well as testing). A related article about this is Peter Naurs seminal paper ‘Programming as Theory Building’.

When doing TDD (test driven development), explicitly expressing the outcome before running a test may not always lead to a surprise. In the very beginning, when a test tries to create an object, without having a class definition, it will cause an error message that is easy to predict.

However, when work has progressed a bit, I regularly run into situation where I expect the next new test to fail in a certain way, but when running the test, the actual error message is a surprise to me. These are situations where learning can happen, by figuring out why the actual behaviour does occur, instead of what I predicted.

Near the end, the surprise is caused differently: I’ll write a new test and expect it to fail. – It doesn’t. Again, this is a good reason to explore why exactly I thought the test would fail.

Particularly in a pair (or ensemble) programming setup, the inability to come up with a new failing test is a sign, that the implementation is good enough … for now.

Recently, I did a programming exercise as part of a technical interview, and expressing my thoughts and expectations while working on the code helped me to find a solution. Additionally, the interviewer didn’t only see what I was typing, but could follow my way of thinking. This relates to Naur’s paper mentioned above: The testing and tested code I wrote isn’t everything there is to my mental model of the given problem or its solution. The way of thinking is important too. This is why I find vocally expressing my expectations & thinking while actually doing the work.

What are your preferred way to actually do the work you’re doing? I’d love to hear about it.

Agile Testing Days 2021 – Part 3

Conferences 1 Comment

If you haven’t you might be interested to read the previous part of this series as well.

This day impressed me most by the three key notes and discussing the effects of corona and working from home with Anne Colder.

Thursday

The first keynote of the day was Ard Kramer’s “How to nudge your way through agile testing”. Ard presented six ways to nudge people to make a decision in a certain way – probably a way that we want them to go. In a very consistent way he made the distinction between doing something (the nudging) and the ethics of doing it.

It’s so important to aware of these techniques, because then we can more consciously decide whether or not to follow the nudging.

These are the six kinds of nudging he explained:

  • Default options
  • Commitment through consistency
  • Anchoring
  • Decoy effect
  • Zeigarnik effect
  • Activate unconscious behaviour

The name Zeigarnik effect was new to me, although I read about the way it works somewhere on the net. Basically it states that one can remember an activity that has been interrupted (not not completed) more easily at a later point in time.

“The Tester’s Learning Toolkit” was the second keynote, presented by Vera Baum. Supported by incredibly great graphics Vera explained the various levels of experience people may have.

  1. Novice
  2. Apprentice
  3. Crafter
  4. Expert

She explained how we can develop from level to level, and why it may not be the best approach to let experts teach novices.

The last keynote of the day – and the conference – was Vernon Richards‘ “What does the ‘Coach’ in ‘Quality Coach’ mean?”. He introduced 6 styles of leadership and how they can be applied in the context of software quality. I loved his way of giving examples his experiences in applying them.

With this highly interesting and super entertaining keynote ended the official program of the Agile Testing Days 2021.

In the evening, I discussed the effects of having to work from home with Anne Colder, leading to another contribution for the ebook “Software People … Work From Home“. Stay tuned. 🙂

This ended a truly brilliant experience of the Agile Testing Days. It was so great to finally meet real testers in real live, discuss software related topics during breakfast, lunch and dinner… as well as in between.

Thank you! Thank you to everyone I spoke to, especially the organisers who ran an incredible conference!

Agile Testing Days 2020 – the Other Two Days

Conferences Learning Tools for Testing 1 Comment

In a previous post I summarised the 1st day of the Agile Testing Days 2020.

Lean Coffee

2020 was the first year, I facilitated a LeanCoffee. Thank you Janet Gregory & Lisa Crispin for inviting me to help!
Since this was an online-only conference, we used a web application and Janet selected LeanCoffeeTable. I found it easy enough to use. I particularly like the ability that all participants can enter actions and learnings during the topic discussions as well as generate a PDF to summarise the meeting. I found this a very pleasant experience.

Here are some of the ideas and insights, I kept:

  1. No Testing Column
    I’ve learned that some teams entirely remove the testing column(s) from their boards. Obviously, this simplifies the board. But more importantly, it also seems to help teams integrate testing tighter with the overall development. This in turn supports teams working as one entity, and not as a number of people who happen to work on the same story.
  2. After all those years: So many topics about testing
    Even after years, in some cases decades in testing, there are still areas that one can learn about, drive into and possibly thrive in. The next point is one that surprised me a bit.
  3. Automated accessibility testing
    At least some parts of accessibility (commonly abbreviated a11y) testing can be automated. More on that later.
  4. Productive ensemble testing
    Test in an ensemble testing (formerly known as ‘mob testing’, similar to mob programming) can be productive even with people that haven’t worked together. This was mentioned by a Lean Coffee participant who joined a group of people (with whom they never worked with before) for a testing session. To their surprise people worked together quite well.

The Last Talk On Software Testing

I had the great pleasure to moderate Rahul Verma’s talk ‘The Last Talk on SoftwareTesting’, where he explained were he thinks the business of tasting (no typo!) went wrong. Entertaining, hilarious and light hearted. And thankfully not actually the last talk on software testing at all. Here’s a very nice summary by Ekaterina Budnikov:

Automated Accessibility Testing

I participated in Cecilie Haugstvedt‘s workshop ‘Automatic Accessibility Testing for All‘.

I was really surprised how far automated testing of accessibility is possible – and how easy it is to get started! In addition to that, I found it interesting that automated a11y (the common abbreviation for accessibility) tests can and should be divided into unit and integration tests.

An important learning: The tests that check contrasts (e.g. of text and background) are integration tests: Most often colours are set site using CSS, so not every article, product description etc. needs to be checked individually. Also the computation of how good (or bad) the contrast is, seems to be more time consuming than I thought it is.

For a first step to get some idea of accessibility of a page in Chrome: Using “CMD-OPTION-I” (on a Mac) or “View ➙ Developer ➙ Developer Tools” (via the menu) open the developer tools. Then go to the ‘Lighthouse’ tab & click generate report.

Moderating a New Voices Track

I also really enjoyed moderating Chris Baumann‘s talk ‘Extreme learning situations as testers’. The talk & topic were so good, some of the attendees stayed in the Jitsi room to discuss the topic for the whole next time slot! The following tweets cover some of the ideas & insights Christian shared with us:

Thank you Mariia for the wonderful summary!

Do you also have insights and ideas you took home (where you probably were all the time anyway, this year)? What are they?

Slow Feedback Cycles

Feedback Learning 6 Comments

In his keynote ‘Fast Feedback Teams’ Ola Ellnestam (at the Agile Testing Days 2012) talked about the importance of fast feedback and how to shorten the cycle durations. To me, there seems to be a trend in focussing on getting feedback in shorter and shorter cycles.

While I completely agree that in many cases it takes too long to notice the effect of a change made earlier, I am also a little bit worried that we (as software developing teams and companies) might forget about  slow feedback cycles. Let me explain.

Feedback loops

Let’s look at aspects of feedback loops. There is an actor to change the system operation as well as a sensor that reads some information. In order to actually be a feedback loop, the sensor is driving the actor.

Note that most systems allow data to be read at any time and (essentially) any frequency. However systems usually also do not immediately respond to changed input. Here’s an example: You could read a thermometer in your room as often as you like. And you can also turn the control of the heater up or down pretty often and yet the room temperature will not change immediately.

Usually there is no point in acting a whole lot faster than the system can react. If it takes ½ an hour for the room temperature to adapt to a newly set value, reading the thermometer and changing the control every minute doesn’t make much sense.

Some waste and some risk

Now, with the focus on short time scales and a high frequency of the measurements (no matter wether they are qualitative or quantitative), I can imagine two undesirable outcomes:

  1. In a situation where the system reacts slowly to changing parameters, measuring often is waste. This is because the system couldn’t possibly yield another outcome (yet).
  2. If we only measure with a rather coarse-grained way (e.g. only the values red, yellow, green), we might miss a slow trend. (I guess this is the reason we often suddenly must buy winter tires, even though we clearly noticed that the temperatures decreased over the past weeks and we’re wearing our long sleeved shirts and anoraks too.)

That said, if the system reacts fast on a change and we can get the feedback quickly, it’s very likely a good idea to actually get that feedback. A good example for this case: Having fast unit tests in programming. 🙂

Sources of Learning

Learning Testing 1 Comment

Over at Jeroen Mengerink’s blog (and there’s the 1st of the sources to learn from) he talks about learning (and the lack thereof) of people in testing. Given the topic list of this blog “On Testing, Patterns and Learning”, this topic is very interesting to me, too.

I recently attended a Scrum Training and one of the group exercises was to suggest ways to implement certain practices we were given. One of the topics was “focus on both, technical excellence and good design, fosters agility” (my translation, the training was held in German). I started filling the spot for possible immediate actions on the board: Conferences, user group meetings, books, blogs, podcasts… at which point a colleague stopped me, so others could add to it. However they didn’t.

So, if you’re looking for information about testing here are some recommendations I have, for today let’s cover the letter ‘B’ 😉

Jeroen also mentioned conferences and especially a presentation by Alan Richardson (@EvilTester on Twitter): Please go to Jeroen’s post and read it, then watch Alan’s presentation, both are really recommended stuff.

For now, I’d love to hear what book(s) and/or blog(s) you recommend that helped you learning about testing or improving your testing.

© 2012-2023 Stephan Kämper — Mastodon

MENU

Navigation

%d bloggers like this: