Blog has moved!

Hi all,

Just a quick announcement that I’ve migrated my blog over to GitHub Pages. If you are reading this it’s likely that you’ve got here from Google rather than through joselima.co.uk 🙂

I’ll be keeping the content here (on wordpress.com) but won’t be updating it!

Thanks

London Tester Gathering Workshops 2016

Last week I attended the London Tester Gathering Workshops.

I was lucky enough to be given a ticket by Jean-Paul Varwijk (@arborosa) who was giving a workshop on “Agile Exploratory Testing”.

I couldn’t attend the first day of the workshops but I went down to London on the Friday to take part in Jean-Paul’s workshop and in the afternoon attend the “Get into Coaching and Mentoring” which would be a nice fit into my new job role at Redgate – Quality Coach.

You can find my notes below, I thought overall it was a great day – I remember attending it a few years ago and was good to see a few old friends. It was also great to meet up with some of the guys from Atlassian, including Andrew who I have been exchanging emails with for a while, trying to understand their QA Model better and how we can incorporate some of its aspects at Redgate. I am really grateful to Andrew for his time chatting and all the information he has provided me over the last few weeks.

Agile Exploratory Testing – Jean-Paul Varwijk

  • He started off asking people to write 10 things they noticed about the room (didn’t matter what they were, just write them down as soon as it comes up in your brain).
  • He proceeded to define what exploration is: the act of searching, for the purpose of discovery of information or resources.
    • Searching – activity
    • Purpose of discovery – goal/direction
    • Information – Something worth knowing
    • Resources – something that helps to advance
  • “In exploration you aim to create a sense-making model instead of a categorisation model”.
    • Resource: Myers Briggs Type Indicator: Categorisation Model, Jon Bach (Agile 2010) “Telling your exploratory story”
  • We then proceeded to explore two different applications:
  • Oracles: Heuristic principle or mechanism by which you recognise a potential problem. They help you evaluate test results.
    • Tacit – Testers: experience, your feelings and mental models
    • Explicit – Testers: inference, observable, consistencies
    • Tacit – Other people: conference, stakeholders, feelings and mental models
    • Explicit – Other people: Reference, shared artefacts (specs, tools, etc.)
  • We then played the ColorGame (http://arborosa.com/colorGame/colorGame.html) :
    • Asked to use oracles
  • We also touched on the various definitions of exploratory testing:
    • The wikipedia definition (which is very similar to James Bach’s)
    • James Bach
    • Michael Bolton
    • Jean-Paul’s own one
  • Heuristics: Oracles are heuristics, but not all heuristics are oracles.
    • SFDIPOT
  • Session-Based Test Management was also covered very quickly as we were running out of time.
  • Planning:
    • Strategy: test plan, coverage risks
    • General: heuristics, test ideas, risk catalog
    • Ongoing planning: weekly planning session, charters
    • Issues, bugs and session sheets
    • Daily Test sessions: low tech dashboard
  • Test story: art of storytelling is pretty important in exploratory testing.
  • Agile testing → Concurrent testing: analysis, design and dev throughout a sprint. Breaking down in small items, improving awareness and responsibility of all team members for the software quality.

QA at Atlassian – Andrew Prentice

  • Does your business really want testers? (or do they want something else and call them testing?)
  • If quality was there, there would be no need for testers
  • Testers can’t be gatekeepers
  • Quality assistance (model) introduction: co-pilot role: goal is to go really fast. Great analogy if you think about the role of a co-pilot
  • Difference between a “10x developer” and a “1x developer” is a quality assistance engineer
  • When developers fail, QA fails too
  • Centralised QA Function:
    • Different team for sharing knowledge, people and resources across products
    • Efficient recruitment, onboarding process, development and management
  • 4 factors:
    • Eradication: cross site request forgery protection across Atlassian
    • Prevention: QA kickoffs, testing notes and demos
    • Detection: automated tests, Developers in Test, blitz testing
    • Mitigation: progressive deployments, feature flags, controlled releases (limited by number of people that get it)
  • 3 different QA Phases:
    • 1: QA only did critical testing (changes), pair with devs for the rest and provide resources
    • 2: devs only doing critical testing, QA focus on kickoffs, root cause and defect analysis
    • 3: no manual testing, QA focus on eradication

Get into Coaching and Mentoring – Tony Bruce and Dan Ashby

I didn’t take any notes during this session as it was very hands on.

  • We started with an ice-breaker (game of “Swoosh”) and then moved to definitions of coaching, mentoring, leadership and teaching.
  • There were a couple of games played:
    • Communications game (that felt mostly about leadership) where everyone in the room got a piece of paper with a picture – the point was that we had to put ourselves (around 22 people) in order from start to finish to tell a story with our pictures: figure out the pattern, figure out the relationship between the pictures and then manage to self-organise so the story made sense.
    • Writing about a shape/picture: there were a lot of circles in my example and I had to describe in 5 minutes how to achieve the same shapes/picture without talking to my colleague (we actually got taken out of the room so my colleague only had access to my poorly handwritten piece of A4 paper)

 

As usual, these are very rough notes, so some information may not be entirely accurate, or representative of what was said/shown during the day. Feel free to tweet me any questions @joseglima

Running your Selenium checks on Microsoft Edge

For the last week or so, after spending some time upgrading some of our existing selenium client machines I thought it would be a good idea to find out more about Selenium checks (tests...) on Microsoft's new browser, Edge.

It's the first time that Microsoft have released a web driver themselves, officially supporting it.

Below are some of the issues I've found whilst using it, and since I had to spend some time digging around GitHub/Google I thought I'd collate them here.

The first problem I found was trying out the example given by Microsoft themselves on their blog (https://blogs.windows.com/msedgedev/2015/07/23/bringing-automated-testing-to-microsoft-edge-through-webdriver/)

The first thing you do is install the web driver (link is in the url above).

Then all of a sudden, without modifying the code posted by Microsoft, the tests would just hang. Upon inspecting the output I could see that:

"Existing Microsoft Edge (pid: xxx) terminated forcibly"

In this case, the problem was with Edge itself. By default, Edge has a startup page rather than a url, and it appears that the web driver struggled to understand that, quitting straight away. Simply go to Edge's options and change this to a url you want (Google or Bing should do just fine).

The next problem I faced when I tried to run those checks was that Edge couldn't be launched if the user was builtin\Administrator. This is a security issue implemented in Windows 10 and to work around it have a look here: https://4sysops.com/archives/why-the-built-in-administrator-account-cant-open-edge-and-a-lesson-in-uac/
(hint: the solution is actually only described half way down the page).

To add Edge as a browser that can be run on a selenium grid, edit the node's configuration file by adding the following (and changing as you wish):


 {
 "browserName": "MicrosoftEdge",
 "maxInstances": 4,
 "platform" : "WINDOWS"
 }
Next issue was that Selenium couldn't detect the Edge web driver. One workaround is to move the place where the installer places the web driver to where you running your Selenium node from (i.e. the same folder). After that, add this to your node startup file (where you also tell it where Selenium lives for example):


-Dwebdriver.edge.driver=.\MicrosoftWebDriver.exe

This should allow you to run your checks using remote capabilities, and here's how I've done it:

var capabilities = new DesiredCapabilities("internet explorer", "11", new Platform(PlatformType.Windows))
var edgeProfile = new EdgeOptions();
edgeProfile.PageLoadStrategy = EdgePageLoadStrategy.Eager;
capabilities.SetCapability("edge_profile", edgeProfile);

The one thing to bear in mind is that Microsoft's Web Driver doesn't yet support all commands that you're potentially used to, like xpath (you probably shouldn't use xpath anyway, but sometimes there is no easy alternative). You can try a newer version ("for windows insiders") of the webdriver that has a preview of the getelement by xpath but it's obviously not in the official release yet, so use it with caution. Check this url to find out what you can and can't do: https://dev.windows.com/en-us/microsoft-edge/platform/status/webdriver/details/

For all the above I have been using Selenium 2.48.2 but I believe bindings were introduced in 2.47.0 to support the new Microsoft Web Driver. I tried to use the latest (2.50.1) but found it too unstable so reverted back to 2.48.2.

Hope you find some of this information helpful.

My first public talk!

I began my professional career as a software tester just over 3 years ago. Back then, if anyone had asked me if in 3 years’ time I would be presenting a topic to a bunch of fellow professionals I would have thought they were crazy.

The first conference I attended was back in 2013, just a year after I started at Redgate. I was encouraged to go by my line manager who was once a tester and also Chris George who headed the testing function around here. Credit where credit is due, without Chris and Ben, I would not be where I am today in my professional career.

During that conference one thing that I briefly thought about was how cool it would be to tell my experiences to others, obviously with the caveat at the time that my experience was very short. But time didn’t stop and as I gathered more experience I decided after attending Agile Testing Days 2014 that I would work on a talk to submit for next year’s event.

When that time came I knew that I wanted to talk about my experience within my team and the design architecture that we have adopted and decided to follow, so I could tell people how my approach to testing had changed. One of the hardest things for me during the whole process was passing the message that I wasn’t there to tell anyone how to test micro services, but to tell them how I’ve done and continue doing, and how my testing was different to what I had done in the past. The reason for this is that I have always worked in the same company, within the same team, and mostly, around the same people.

So my talk got accepted and I was invited to be in the “Young Agile Talents” track which took some pressure off, but at the same time the “talent” word added some on top. It’s great that conferences are giving young (in terms of age or experience) people the chance to give talks and to share their experiences. If you are looking for help, Speak Easy program offers you the chance to be mentored by an experienced speaker who will help you all the way from coming up with an idea for a talk or workshop, to the delivery. They also have agreements with a lot of different conferences where there’s a guaranteed slot for one of their mentees.

After a few months of just thinking about my talk it was sort of time to put ideas into an actual presentation and I used a lot of my peers for this, as well as external people. Within Redgate I must thank Gareth Bragg, Chris Auckland, Andrew Fraser, Robin Hellen, Danielle Ainsworth and Toby Smyth who saw a very rough draft of my talk and literally grilled me afterwards with questions and feedback. Outside, I must thank Emma Armstrong for also looking at a very rough presentation and providing me with encouragement to make it better. And finally thanks to Chris George for giving me an alternative order of my slides which no doubt made a lot more sense.

All in all it was a very fulfilling experience, one that I would most likely try to repeat.

You can find my slides here if you are curious to know what my talk was about: http://www.slideshare.net/joseglima/exploratory-testing-micro-services

I was also asked by InfoQ to do a short Q&A which you can read here: http://www.infoq.com/news/2015/12/developing-testing-microservices

What I learned (for someone that has never presented at a conference before)

  • There are a lot of conferences out there in most fields, pick one that has a good track record at giving people opportunities like lightning or consensus talks;
  • Work in small chunks on your presentation and iterate on them – yes you will most likely still make changes the day before but hopefully that won’t have any impact on the presentation itself;
  • Get feedback as early as possible, even if it’s just on what you are thinking about presenting;
  • Act on that feedback very soon after you get it, otherwise you will lose some of the context;
  • Enjoy the occasion, and try to still enjoy the conference you are at!

Agile Testing Days 2015

November in my work calendar means only one thing: Agile Testing Days 2015.

This was the 3rd time I participated in ATD, although this time as a speaker which was a really interesting experience.

As usual what is always great at ATD are the conversations and I was lucky enough to speak to Anne-Marie Charrett and find out how she has been coaching testers at her organisation and the challenges she has faced hiring new testers. The MIATP award party on Tuesday night was also brilliant and it was good to meet some new people from around the world.

One of the highlights of the conference was playing the pen game with my colleague Andrew Fraser (who has also published his conference notes on his blog, which are a far better representation than mine! check them out here) and playing some testing games on the Wednesday night!

I will write a separate blog post about the talk I presented but here are my (short) notes taken during some of the keynotes and talks I attended.

This year I also missed the tutorials day due to schedule restrictions so I’ll go straight to day 1. I hope you find these notes useful, but if you have any questions or want some clarification feel free to leave a comment!

EDIT: You can now find the slides from all presentations here.

Day 1

“Where words fail music speaks” Keynote by Huib Schoots and Alexandra Schladebeck

  • what’s common between music and testing
    • instant feedback
    • reduce complexity to practice
    • learn fundamentals (own them)
    • muscle memory
    • you don’t practice from front to back
  • teams have the same soundtracks, they are on the waves (i.e. understanding)
  • hero complex, music teams and their contexts
    • solo
    • trios/quartets
    • bands
    • orchestras
    • sessions
  • STAR heuristic
    • structure
    • tune
    • accompaniment
    • rhythm
  • know what your cadences are… (authentic and deceptive, like musical notes)
  • exploratory testing and music:
    • scripting versus improvisation
    • communication over documentation
    • standards and music
  • experiments: outcome is unsure
  • non-deterministic and non-reproducible
  • models: based on experience, culture, etc.
  • lessons:
    • learn your team’s tune
    • finish your sprints on a good cadence
    • recognise your role and context
    • practice, patterns, adapting = you’ll be a star

 

“Experimenting in context for Exploratory Testing” Talk by Maaret Phyajarvi

  • replacing a test case driven style with a learning tester driven style in two organisations
  • what testing gives us:
    • unit testing: spec, feedback, regression, granularity, testing as artifact creation
    • exploratory testing: guidance, understanding, models, serendipity, testing as performance
  • data intensive application
    • things that couldn’t be changed at certain organisations (the “givens”)
      • waterfall process
      • contractual distance between acceptance testers and subcontractor
      • test case metric based reporting
      • manage, don’t test
      • business end users as testers
    • things that have changed (the “experiments”)
      • acceptance tester degree of freedom
      • test cases from step by step scripts to test data with process outline for notes
      • making change requests acceptable
      • reporting ~20% of testing to 3rd party
      • unofficial tips sharing sessions with the subcontractor
  • Function intensive application:
    • “Givens”
      • roadmapping creating disconnect to current priorities
      • tendency for remote work
      • developers doing majority of testing
      • requirements / specifications format as UI spec
    • “Experiments”
      • no test cases or wasteful documentation
      • tester with developer tools
      • removing “acceptance testing” by moving testing to the team
      • continuous delivery (without test automation)
      • holding space for testing to happen
      • true teamwork with mob programming

  • PROOF
    • past
    • results
    • obstacles
    • outlook
    • feelings
  • vision, current charter, other charters, details (bug reports)
  • charters to give ideas of exploration

 

“A happy marriage between context-driven and agile” Talk by Ilari Henrik

  • Automate everything?
  • checking vs. testing
  • checking the algorithmicly catchable stuff
  • TDD is not testing
  • automated check:
    • passed – ok or missing a bug
    • failed – there is a problem or false alarm
  • “Embedded testers”
  • Context-driven and agile manifesto
  • context driven testers will “click” really well in agile teams
  • ilari.com/agile PTE Agile Testing Manifesto
  • how we do it:
    • get involved early
    • bridge between developers and testers
    • pair on tasks
    • educate the team about testing
    • technical awareness “I comment my code – but I still don’t know what I did or why”
    • domain knowledge
    • willingness to learn
    • when crafstpeople meet other craftspeople, that’s when the magic happens

 

“Testers are dying” Keynote by Karen Greaves and Sam Laing

  • There’s more demand than there’s capacity – testers aren’t dying
  • 6 steps:
    • awareness
    • punishment (different tariffs, rates going up)
    • personal responsibility
    • remove barrier
    • visible impact
    • start a movement
  • trends:
    • pressure at the end of the sprint
    • often asked to release without testing
    • testing is always behind development
    • blame around bugs
    • automation is at least a sprint behind
  • personal responsibility by different boards – different columns like “show me”, “review (in pairs)”, different colour coding

 

“The human refactor experiment” Keynote by Bryan Beecham

  • horizon of predictability: we can only see so far into the future
  • moment of maximum ignorance
  • get past mental limits – other people will start buying in
  • 23 1/2 hour challenge
  • refactoring:
    • exercise
    • diet
    • continuous improvement
  • make the world a kanban board

 

Day 2

“If I can do it so can you” Keynote by Dr. Sue Black

Dr. Black told the audience the story of her life right from growing up in the suburbs of London to forming a campaign that helped save Bletchley Park, the home of the World War II code breakers. Really inspirational.

 

“Shift left and shift right – the testing swing” Talk by Laurent Py

  • journey from waterfall to agile
  • breaking silos
    • speed of feedback loop
  • put value before correctness
    • why? is it worth doing?
    • how to ensure quality of deliverables?
  • testing matrix
    • build / production
    • what should we buid and why? is it really worth it?
    • how to automate? is it really reliable and does it scale?
  • good for challenging business assumptions

 

“There is no secret sauce” Keynote by Ben Williams and Tom Roden

  • investing in impact model
  • are we investing in the right things?
  • what aren’t we going to do now?
  • investing in impact – a leaner approach to investing in software
    1. decide to invest – explicitly acknowledge hypothesis (between writing software and making money), consider this investment in the context of others
      • diversification: people’s skills, technical component
    2. establish performance boundaries
      • ranged planning
      • pro actively manage risk
    3. measure income
    4. measure impacts
    5. decentralised decision making
      • steer by exception
    6. learn

 

“Test beyond quality, beyond software” Keynote by Mike Sutton

  • Steve Blank’s book “Startup Owners Manual Step: The Step-By-Step Guide for Building a Great Company
  • agile teams are a place to cultivate behaviours and cultures for a new reality
  • it’s time for agile teams and testing discipline to go beyond software, beyond testing and into organisations
  • ask questions, go where they lead
    • “Why does it take so long?”
    • “What if?”

 

Day 3

Unfortunately, after giving my talk I didn’t take any notes from the two keynotes I attended. The first one was by Tom Bradford “Nowhere and back again: a software engineer’s tale” in which he described his career in software (development) and how he tried to quit before only to go back and hope to make things better. The second one, which was also the final keynote of the conference was from Olaf Lewitz “Integral Quality” in which he talked about quality across all parts of the system and the organisation and what we could do to change that.

Agile Testing Days 2014

Last November I attended Agile Testing Days 2014. If you read my previous posts you would recognise this was the second time I attended the conference.

It was great being back in Potsdam, Germany, and see many familiar faces, including some from across the pond whilst also meeting new ones from all over the place.

This time I had decided I would pace myself in terms of the number of talks I attended, the tweets I posted and the notes I took, just so I could enjoy more of the conversations and attempt to take less information in but at the same time hoping I would be able to retain it for longer and use it more consistently afterwards.

Below are the notes I took during the 4 days, which started off with a tutorial day on a Monday.

“Technical testing in an agile environment” by Alan “The evil tester” Richardson

  • Technical testing:
    • reminder to keep going deeper
    • tool augmentation
    • technical details will:
      • inspire more testing
      • identify more risks
      • identify different problems
    • not limit our testing to acceptance criteria
  • MORIM:
    • Model: understand different viewpoints
    • Observer: corroborate, invalidate model
    • Reflect: find gaps, lack of depth, derive intent
    • Interrogate: focussed, deep dive observation with intent
    • Manipulate: hypothesis exploration and “how we do stuff”
  • tool augmentation:
    • is not automation, it uses automation
    • passively observe, maintain history of observations
    • alert specific conditions
    • observe the unobserved, and interrogate the inaccessible
    • help model, reflect and manipulate
    • never tools to control, tools to augment
  • go beyond the surface structure
    • transformational grammar
    • surface and deep structure
    • chomsky
    • multiple surface structures
    • single deep structure
      • filtered, biased, distorted -> surface structure
    • questions operate as tools to investigate surface to deep mapping people
  • how to do technical testing:
    • identify tools
    • questioning systems at different surface levels
    • learning system structure technology
    • model system surface structures
    • observe system surface structures
  • automation? sure if you have time;
  • “EditThisCookie” plugin;
  • fiddler and use of its breakpoints feature;
  • burpsuite;
  • WebHackers handbook;
  • “The tangled web: a guide to securing modern web applications”;
  • retrospectives:
    • don’t just pat on the back
    • raise process issues that impact
    • agree what to do about them
    • treat broken windows
    • you might have to be mr. nag and mrs. nasty
  • standups:
    • pay attention to changes
    • describe in value terms
    • see help, pairing
  • acceptance tests:
    • abstraction layers
    • re-use abstraction layers for adhoc automation as well as acceptance tests
    • seek to understand technicalities as well as domain
    • pair

I really enjoyed this tutorial day – it was probably my first tutorial where the majority of our time we spent doing what we do on a day to day basis which is testing software. Yes we got stopped and had some time limits, but those breaks were used very effectively not just by Alan but also by everyone in the room where we shared our experiences and different tools we use in our technical testing role. The only improvement I would suggest to this tutorial would be more pairing and different pairs for the testing exercises as it could spur up more conversations and it would set the tone up for more people to carry on doing it during the break and also during the rest of the conference. But I must say a big thank you to Alan for this tutorial as it was certainly the most useful tutorial I’ve been to so far in my career 🙂

Day 1

“Welcome to the future! Preparing for our agile testing journeys” by Lisa Crispin and Janet Gregory

  • Preparing for the future, or the agile future…;
  • what are the challenges, what can testers do? How can we change conversations?;
  • ability to broaden t-shape skills (breadth and depth);
  • ability to learn, become a t-shaped tester, cognitive learning skills, take charge of your career;
  • customers assume that we know what they want and they want us to deliver exactly what they are thinking;
  • sometimes it’s better to train people than automate certain processes, ask good questions, walk people through;
  • borrow from other disciplines, like business analysis (the 7 product dimensions);
  • change it:
    • from counting bugs
    • from counting metrics that do not matter
  • we have to start thinking about all kinds of risks – call for more risk assessment?;
  • models can help us chose how to attack a problem;
  • serious play is a great way to learn about new things (play, observe, innovate);
  • inspect and adapt: try again, scrap it and try again – what’s next for you?

“A poet’s guide to acceptance testing” by George Dinwiddie

  • We want tests to last over time;
  • not just automated tests, the way you express yourself counts;
  • you need to start thinking about the theme, then start analysis each part;
  • without context words can be confusing;
  • “Given Mary had a little lamb, When Mary went to school, Then the lamb went to school”;
  • purpose is to be picky so words can stand the test of time;
  • some words like everywhere can be quite hard to test against – use examples that cover a good range of options;
  • when a scenario has too much setup that’s a clue – you may not need all that;
  • why do we write tests that ask question of what we should do? We should ask what the system should do;
  • purpose of this talks is that words matter – pay attention to them.

“From good to great: Combining session and thread-based test management into xBTM” by Michael Albrecht

  • SBTM/TBTM/xBTM: models, mindmaps and automatic reporting;
  • xBTM in a nutshell is both session and thread based test management;
  • James Bach’s exploratory testing spectrum;
  • session: test charter – what and what problems;
    • produce a session report (time, bugs, setup, defects, issues and notes);
  • PROOF – past, results, obstacles, outlook and feelings;
    • past and results are very similar in the report
  • ratio for session based test management is 15 minutes test design, 90 minutes test execution or 10/60 minute ratio;
    • fixed length
    • planned (charters, key areas)
    • reviewable (reports)
  • TBTM – threads are a test activity or test idea;
  • use mindmaps to generate threads;
  • to do list, no timeboxing, working in parallel, mind maps;
  • xBTM – models for test design (you show a map to point a country for example);
  • “yed” tool;
  • using a mindmap, navigate through the flow of the system to guide your session/test design.

“Strategy testing // building a product users want” by Roman Pichler

  • What a boss wants vs. what programmers want – programmers just want to give it a go, build a prototype and see if it files;
  • vision – your goal;
  • strategy – path to the goal;
  • details – steps;
  • who are the users and who are the customers?
  • “find an itch that’s worth scratching”;
  • test your strategy – areas of uncertainty, risk assessment;
  • go and talk to your users about the experiences and how they use (your) product today;
  • create a failure tolerant environment.

“The antimatter principle” by Bob Marshall

  • Golden rule – treat as you want to be treated;
  • platinum rule – treat people as they want to be treated;
  • the antimatter principle – antimatter is the most expensive/rare substance known to man;
  • attend to people’s needs;
  • why do we do software development? Why do we do testing?
    • to attend to people’s needs
  • autonomy, mastery and purpose – Dan Pink;
  • Non-violent Communication by Mark Rosenberg;
  • our default mode when we are “not thinking about anything” is to think about ourselves in relation to others – neuroscience research;
  • theory x or theory y organisation.

“Testing the untestable” by Peter Thomas

  • You don’t know what you don’t know;
  • Dan North’s “deliberate discovery;
  • blue green deployments (continuous delivery);
  • the third way;
  • sometimes “The best testers… are your users”;
  • monitoring over testing…;
  • look for abnormal patterns in your data, usage, etc.

“The pillars of testing” by David Evans

  • Model: a (sub) set of things to create or improve within a development or testing process;
  • “all models are wrong, some of them are useful”;
  • Confidence, above safety and courage;
  • stronger evidence, better test design, greater coverage, faster feedback;
  • collaboration and communication, business engagement, team structures, test techniques, skills and experience, effective automation, application testability, configuration management;
  • there’s also the bottom layer which represents the strong base;
  • then there’s the foundation layer;
  • this model can be used to discover or apply root cause analysis;
  • it can also be used to assess, survey teams and organisations, rate the perceived success and importance of each element and look for hotspots and for variances;
  • confidence is the balance of safety and courage.

“Don’t put me in a box” by Anthony Marcano

  • Most people tell you what they are instead of what they do;
  • categorisation still defines what we do for example mum and dad duties;
  • quality comes from people and not from processes;
  • sharing the responsibility within the team doesn’t stop people having expertise or being the expert/reference point, but we may not need him/her all the time, we can all do it.

“Pull requests and testing can be friends” by Alan Parkinson

  • Use files changed in pull requests to guide your charters and your exploratory testing;
  • ask questions in the pull requests comments feature to learn about risks;
  • learn from history;
  • see who contributed what.

“Lateral and critical thinking for testers” by Dan Ashby

  • Left and right side of the brain;
  • left – critical thinking;
  • when we got the information upfront it’s a lot easier to ask questions
    • it’s hard to use critical thinking alone!
  • lateral thinking is when thinking leads the information;
  • “Lateral thinking” by Ed de Bono;
  • Lateral = side thinking.

“Communication: What are you thinking about?” by Shachar Shiff

  • Bad communication causes failure;
  • “Visual aids improve communication”;

“Helping testers add value to Agile projects” by Alan “The evil tester” Richardson

  • Testers adapt different filters to different systems;
  • waterfall projects:
    • removed waste
    • responding to need, not want
    • exploring more
    • taking responsibility for my testing rather than conforming to the process
  • view it as systems rather than agile;
  • testing needs to remain viable and needs to add value;
  • steal from other disciplines (systems thinking, cybernetics, etc.);
  • ownership for testing;
  • exploration beyond acceptance criteria;
  • we need strategies that cope with things coming fast and things getting delayed.

In summary, Agile Testing Days was yet again a great conference and a great week spending some quality learning time with people that I previously admired and new people I met and learn to admire. Tuesday night I saw Matt Heusser getting his Most Influential Agile Testing Person award for 2014, which I was happy for as I voted for him, and also the Brazilian National Team was awarded 1st place in the Software Testing World Cup. Most of the other nights were spent in the bar chatting with people from all over the place, whilst also helping out at the Games Night on Wednesday where I was (as you would expect) one of the people co-ordinating the SET game table. Also had the chance to act as the coach in the infamous Pen game to two of my Redgate colleagues. What can also seem as an off topic to some people, and hopefully on topic for some others, we also went to one of the “Lock rooms” in Berlin where you have to solve a variety of puzzles in order to get out of a locked room – that also opened my eyes to the variety of skills testers have and it was great to further meet some people and chat some more in a slightly more relaxed environment (except for the fact we were locked in a room!).

Hopefully see you at Agile Testing Days 2015!

CAST 2014

Back in August 2014 I was fortunate enough to attend CAST 2014.

CAST, which is organised by AST (Association of Software Testers), is an annual software testing conference bringing attendants and speakers from all over the world. This year’s edition was held in New York, at one of New York University’s buildings overlook 5th Avenue and Washington Square Park. This location was as convenient as it would get for me, considering I would be flying to another continent – it only takes 6 hours (give or take) to fly across the pond and land in New York.

IMG_2032

I arrived in New York on the Sunday, a day before the conference started, and arrived just a little bit too late in the afternoon to take part in the “Scavenger’s Hunt” that took place around the area.

Monday was a tutorial day and I took part in “The art and science of test heuristics” led by Fiona Charles, which I will be covering the main points below.

Monday evening I went down to the bar where a few attendants and speakers were gathering and played a few test games, the one I particularly took a liking for was SET. SET is a pattern recognition game – it’s brilliant to get your brain working again and one of my colleagues has even suggested playing it before the start of every meeting to make sure everyone was in gear and ready to work.

Tuesday and Wednesday were to be your standard conference days, with keynotes and talks given by speakers, and I surely made the most of it. Apart from the usual conversations I was also lucky enough to take part in a testing challenge on Tuesday evening where we were asked to test a Test Execution tool developed by one the challenge sponsors. I was “recruited” via twitter where several people were forming teams and ended up in a 8 people team. It was great to be able to pair up with someone that I never met before and I certainly got a few tips from him (Michael Corum @TNRidgeback). The results were announced the following morning and our test report was considered to be the best one alongside another team’s, but the others got the prize in the end, considering they had less members and produced a slightly better formatted document. Wednesday evening a few of us went out for a meal after the conference had finished, which was really good to meet even more people from the community and share experiences – it’s great to find out that other people have the same professional struggles as you even though they are separated by thousands of miles. It’s also good to know that you’re at least on the right path, and in my case actually quite fortunate to work somewhere as good as Red Gate. The evening was rounded off with a few drinks and yet more testing games, in particular the Pen game which myself and Michael Corum paired on, to try and solve the puzzle. We eventually got it, after quite a few attempts and some excellent coaching from Stephen Blower.

Overall this was an amazing experience, and the people I met were once again one of the highlights. But, of course listening to the likes of Michael Bolton, James Bach, Fiona Charles speak was really enlightening, and the amount of learning that took place over the 3 days was great. It was also great to see familiar faces like Pete Walen, Matt Heusser, Jean-Paul Varwijk and others I met at Agile Testing Days.

So below you can find my notes about the keynotes, talks and tutorial I attended. Hopefully, they are of some use to you.

“The art and science of test heuristics” Tutorial by Fiona Charles

  • Started off with a knot problem where each group (of 8 people approximately) would form a knot with their hands
    • it led groups to understand the problem, and in turn question the requirements
    • refactor our initial model for solving the problem
    • control the scope – we had too many people in the group for example
  • sometimes you have to abandon certain models;
  • children games are great to understand heuristics and models;
  • prepare to re-model
    • re-model -> embrace chaos
    • challenge the assumptions regularly
    • focus and de-focus
  • how would you go about this?
    • google it!
    • watch your initial assumptions
    • over think it!
    • previous experience
    • instructions can be useful
    • look at patterns
    • trial and error
    • multiple oracles
  • reverse strategy – start with easy first and vice-versa;
  • throw away work and re-do;
  • limit on permutations – find a way to cut through;
  • step away from problems and take a break;
  • switch technique;
  • diversity on a team can be good but also cause a problem;
  • being lucky – surely you must find your own luck;
  • problem could be bigger than you thought;
  • rule: use machines for what they are good at;
  • beer fridge problem (https://www.youtube.com/watch?v=t41wNkGvJ9k)
    • previous experience
    • tech limitations
    • personas (diversity/multiple people)
    • (not) follow instructions
    • act on feedback
    • varying input
    • curiosity
    • consider audience
    • visually appealing (objects)
    • continuous learning
    • context
  • you don’t stick quality in;
  • if you don’t pass one test criteria, don’t go into the next one;
  • tactful communication
  • follow the money
  • danger in following heuristics – change them?
  • art – creativity coming up with heuristics;
  • science – analysing/measuring those heuristics.

I really enjoyed the tutorial day. It was a simple start and it was great to hear what everyone thought heuristics meant in their own context. To me, heuristics are rules of thumb. Something that will help me and steer me in a certain direction to try and achieve a certain goal or prove something. In a way, this gives me the correct behaviour expected, but also allows to think what may or may not happen instead and lets me follow a variety of paths. The variety of games and exercises done throughout the day were great and Fiona had great input with all her knowledge on certain things that we may have been missing.

“Testing is not test cases (towards a performance culture)” by James Bach (keynote)

You can watch the keynote here and the slides are here. Below are some of the notes I scribbled down during the talk.

  • Analytical lag time – time between experiments and the results come up/are shown;
  • “Testing is not test cases”
  • use charters for testing – they will help you;
  • there’s no test for “it works”;
  • Pro Clip – James Bach tool to generate test data;
  • analytical testing is different to analysis of output;
  • every act of testing involves many layers (slide #3);
  • fresh-eyes-find-failure heuristic (slide #5);
  • importance of precise words as testers communicate;
  • highlight text if you’re not sure it’s a bug and you need clarification with developer or someone else;
  • “I don’t yet see a problem here” rather than say “It passes”;
  • last thing a tester should do is just follow instructions, it’s not intellectual enough;
  • a test case is a set of ideas, instructions, or data for testing some part of a product in some way;
  • test automation saying is toxic – testing can’t be automated, just like test cases don’t contain testing;
  • you don’t ask developers if they are a manual or an automated programmer, so why would you say it with testers;
  • managing tacit knowledge – real testing ability cannot be spoken, it’s tacit knowledge;
  • testing cannot be encoded (slide #12);
  • struggle through practice and examples, not certification;
  • checking is part of testing, just like tyres are part of a car – just not everything – you may not need much testing on your project; test exploration or design work can lead to valuable work – you may not need deep testing to happen again;
  • testing as a performance – like an actor in a play;

“My boss would never go for that” by Alessandra Moreira (talk)

  • Testing and the art of persuasion;
  • ideal world != real world: managers not always know about testing or even the skills a tester has;
  • persuasion: process by which a person’s attitudes or behaviour are influenced by communications from other people;
  • persuasion != coercion; manipulation; one way street;
  • pesuasion = influence; guidance; negotiation;
  • if you present your evidence in a certain style they prefer to hear it – visual;
  • “grow your credibility as a craftsman” James Bach;
  • know your craft:
    • build credibility
    • part of being a good tester
    • how do you know your way is better
    • keep learning
  • build a solid case:
    • arguing skills can be learned
    • consider your boss’ point of view and business priorities
    • gather supporting evidence
    • other possible questions?
  • communicate clearly:
    • use your manager’s communication style
    • present compelling evidence
    • link your priority to your boss’
  • compromise:
    • listen and include different perspectives
    • prepare small compromise in advance
    • start small
    • be prepared to incorporate new ideas
  • things to remember:
    • resisting change is natural
    • most managers want you to succeed
    • be patient
    • find a support system
  • common mistakes:
    • upfront hard-sell
    • too many buzzwords
    • assuming it is a one shot
  • so:
    • figure out why, build a sound case, know your craft, prepare, compromise and be patient.

“Scaling up with embedded testing” by Trish Khoo (keynote)

  • The more we could do at the start, the more challenging testing gets because not many obvious bugs are propping up;
  • developer find and fix, tester verifies expectations;
  • [at Red Gate, at least in my current team, I consider myself quite lucky regarding this as developers are often asking “How are we going to test this?”];
  • take tester our of the feedback loop between dev/tester/product owner and the feedback loop becomes a lot quicker;
    • pivotal
      • “we don’t actually have a QA department” (Elizabeth Hendrickson)
      • developers doing exploratory testing
      • eliminating the time spent explaining what has been done
    • microsoft
      • “it should be hard to find bugs” (Alan Page)
      • ultimate goal in a software engineering team is to engineer software
    • google
      • “quality is team owned not test or QA owned” (Michael Bachman)
  • raising the bar:
    • how can we as testers improve, and start using our, now, free time to provide value?
    • you can’t expect developers to know about testing practices from one moment to the other;
  • learn about human computer interaction, statistics and modelling people.

“Psychology and Engineering of Testing” by Ilari Aegerter and Jan Eumann (slides) (talk)

  • Testers and programmers mutually respect each other – both parties bring a good variety of skills;
  • PTE Agile Testing Manifesto
  • pair on tasks – pair on exploratory testing with developers;
  • educate the team about testing – workshops, dojos, katas, etc;
  • skills needed to make this happen:
    • technical awareness (coding, reading code, database expertise, test environments, service configuration, etc.)
    • domain knowledge

“Paint like an engineer – skills in testing” by Alexandra Casapu (talk)

  • Best way to work on skills is to do something, get feedback, improve it and keep doing this;
  • discuss the method, and apply engineering methods;
  • taxonomy of skills:
    • heuristic does not guarantee a solution
    • it may contradict other heuristics
    • it reduces the search time for a solving problem
    • its acceptance depends on the immediate context instead of an absolute standard
  • do a “my personal testing skills”
    • categories: human-human interaction, attitude determining, rule of thumb, information visualisation, risk-controlling
  • use quiet times (Christmas, other people’s vacations, etc.) to learn or do new stuff;
  • skills you’re not using you will lose them;
  • skills are a procrustean bed (procrustean myth);
  • not just learning a skill but interaction between these skills;
  • nurturing skills – choose some areas; learn the queues that lead to mistakes; recognise when need help.

“Patterns of automation” by Jeff Morgan, founder of leandog.com (talk)

  • Specification by example:
    • specification – user story with acceptance criteria
    • implementation – code with unit tests
    • verification – automated tests
    • duplication in the above points
  • PageObject pattern:
    • web service, web apps, mobile application, data warehousing app
    • stops the need to go and fix tests that have broken in different places – makes it easy to fix in just one place
  • Default Data pattern:
    • use ruby gem to complete data we don’t care about
    • just testing for one thing – focus on the things that really matter and remove the noise
  • Test Data management
  • Route Navigation
    • we do this all the time to achieve something
    • the way we navigate may change things
    • pattern helps us navigate through different paths to reach the same point (i.e. page in a website(s))

Day 2

“STEM to STEAM – Advocacy to Curricula” by Carol Strohecker (keynote)

  • Science, technology, engineering, (arts), math;
  • network for sciences, engineering, art and design – spin off international network;
  • “Need to explore the ontology of software testing” James Bach;
  • “BDD is a design methodology, not a testing methodology”;
  • observing – requires additional patience, concentration and curiosity;
  • imaging;
  • abstracting – focusing, simplifying and grasping essence;
  • innovative thinking;
  • pattern recognition – perceiving information;
  • pattern forming – combining elements/operations in a consistent way that produces a (repetitive) form;
  • analogising – recognising functional likeness between two or more otherwise unlike things;
  • body or kinaesthetic thinking – sensation of muscle, sinew and skin; sensations of body movement, body tensions, body balance (proprioception);
  • empathising – putting yourself in another’s place, getting under their skin, standing in their shoes;
  • new tools:
    • modelling: represent something
    • playing: practice
    • transforming: “segwaying” from one of the “tools” to the other
    • synthesising
  • intuition, inter-disciplinary work;
  • “Inventing Kindergarten” by Norman Brosterman and Friedrich Froebel

“Testing in an agile context” by Henrik Andersson (talk)

  • Definition of checking (Michael Bolton);
  • confirming existing beliefs, check that the code hasn’t been broken;
  • testing != checking, explain the differences between them;
  • removing coding from programmers can extend the feedback loop and decrease value;
  • “Testing is focusing on exploration, discovery, investigation and learning”;
  • “See new information, see things differently, driven by questions that haven’t been answered before”;
  • pair on:
    • product owner on design of acceptance test
    • on doing exploratory testing session
    • understanding the customer
    • programmer on checking
    • programmer to understand the program
  • be a coach on testing for the whole team to provide other perspectives;
  • pick up, try and learn new testing stuff otherwise you will run out of wisdom to share;
  • do what you can to be valuable, if you can’t do something else, move on;
  • “I’m here to make you look good” – change this to “make us”;
  • the A-Team works because it has one “crazy” guy – be that guy and test boundaries;
  • session-based test management
    • way to manage exploratory testing from Jon and James Bach
    • charters
  • tester velocity:
    • number of sessions available over the sprint
    • planned out of office
    • planned other things
    • actual available number of sessions
  • make you stand-up contribution useful, use a scrumboard for example;
  • metrics on test time used – bug investigation, set up, learning performance, integration, “testing”, etc.

“There was not a breach, there was a blog” by Ben Simo (keynote)

You should really watch the full keynote here. My notes are very short on this keynote, mainly because Ben managed to get everyone’s attention constantly as a great speaker, and his content shows clearly his passion for the craft of testing that we should all aim for.

  • Security wall can only be there if there is security at every point;
  • system under scrutiny was already exposing itself in usernames – potentially it isn’t a problem but for healthcare.gov it definitely was – same with email addresses;
  • explore in browser developer tools – loads of information could be leaking through web requests;
  • watch out for security reset questions;
  • rest service outputting the GUID (for resetting password via email) on the browser web request;
  • do not include user and GUID reset code in the same email;

“Thinking critically about numbers: defence against the dark arts” by Michael Bolton and Laurent Bossavit (workshop)

A workshop from Michael Bolton doesn’t come around all that often. To no surprise the room reached its capacity fairly quickly so it was just a matter of time to start it all off.

Here are the key points of the workshop:

  • We were asked to investigate a number of different claims;
  • we had to note what it would take to change our mind, whether we thought the claim was true or false;
  • heuristics and tactics used:
    • locate the primary source
    • finding cited work quickly
    • image search for variants of the same chart
    • search by date to find when a claim was first made
    • original data allows you to plot your own chart
    • locate other claims about the same phenomenon
    • search for quotations
  • two tracks about the world
    • claim
      • construct
      • observation
      • metric
      • generalisation
      • representation
      • interface
    • claimant
      • existing bias
      • sources
      • trustworthiness
      • motivation

“Software Testing state of the practice (and art! and science!)” by Matt Heusser (keynote)

  • Have we swung the pendulum too far to programming with agile?;
  • automation and technology is increasing across society;
  • intractable trasience of test;
  • we have a high turnover in test, perhaps that’s ok? perhaps we need to plan accordingly;
  • fragmentation within testing – different keynotes talking about testing as different things;
  • we use words we can’t agree on;
  • result is an ignorance of test;
  • healthcare.gov was probably tested very well but they were “told off”;
  • social structure makes hard to make corrections;
  • in software development, agile (scrum, careful with assumptions) is winning;
  • scrum was created because of constant change of requirements, vision, etc;
  • xprogramming – need for shorter releases;
  • scrum sasy that testing should be done by embedded members of the (development) team;
  • how to win big? save the scrum;
  • system thinking skills applied to getting rid of queues and wait states;
  • honesty (smart empowered testers can do amazing things);
  • experts on context

CAST was an amazing conference, one of the highlights of my year. I hope to attend again at some point. Hopefully you have got something out of my notes. The call for participation is now open and you can check it here.