QA Automation Advocate
Gennep, The Netherlands
Ewald is a Quality and (test-)Automation advocate, consultant and engineer. He has worked with many companies, technologies, domains, and most important of all: many different people!
With a passion for education and sharing knowledge Ewald loves giving workshops, training programs and talks.
He is a father, a husband, an outdoorsman, a musician and a voice for quality engineering!
The 'laws and principles of quality' are not limited to the world of software development. They can be found in all aspects of life and it is the single most important source of inspiration to all of Ewald’s workshops, talks and stories.
Ewald prefers to embed a lot of personal stories, experiences and humor into his talks to make it easy to sit in, relax, listen and stay with the session even if it's scheduled for a Friday afternoon after a 3-day conference. You will not be put to sleep: On the contrary!
Area of Expertise
Why does it take most people 6 to 12 months before they feel fully onboarded (i.e. 'settled') in a new place or job? Wouldn't it be great to start thriving on day 1? In other words: "stick the landing".
During a long journey, starting at only 17 years old when joining the army, I've learned many (hard) lessons which often resulted in situations with little comfort and little confidence. There and then I learned the greatest skill of all: 'getting back up'. Only now I do realize that this long 'search for identity and purpose' set me up perfectly with the right skills, mindset, and experience to thrive in the actual world.
As a quality consultant in tech, working typically with a client for only 1 or 2 years, I don't have the time to get 'adjusted' or 'settle in'. And I don't need to. Anymore...
Join me as I share personal (war) stories about 'the army', 'the road to software development', 'leading cultural change towards a quality mindset', and many more. Share in these lessons with me and take home with you the ability to thrive!
Have you heard of Cypress but never really had the chance to play around with it? Well here you go!
Cypress is one of the most popular tools for end-to-end test automation. Actually it has a lot of 'framework' characteristics. This means that in order for us to fully 'yield' its potential we need to do things a certain way and keep to certain rules or best-practices.
That is exactly what this workshop is all about! After this workshop you will have the skills and knowledge to work on any Cypress project or setup your own in an effective and sustainable way. You'll be aware of the pitfalls!
In this tutorial we will not just dive in and start automating (like crazy) just because we can. We will build a solid foundation first by exploring why well designed (and implemented_ test automation frameworks still seem to fail and some (technically) lesser designed frameworks could still add more value. The questions we need answering before actually diving into tools is: "Why do we need or want a test automation framework?" and naturally also "What characteristics are most valuably to my/your specific situation?". Once you understand the (and your) purpose for (e2e) test automation, we will start shaping our test automation framework. To make easy to get started I will provide a (publicly hosted) system-under-test (SUT) for which we will build a test automation framework using Cypress Cypress is one of the most popular tools in test automation and has a lot of 'framework' characteristics. This implies that Cypress wants us to do things a certain way. That doesn't mean that the learning curve is a steep one: on the contrary! Cypress is actually not that difficult to master but it might look 'funny' at first. You'll get used to it! During this tutorial we will cover all of it's typical characteristics and how it differs from other great tools like playwright, testcafé and selenium. This tutorial is meant for Cypress-beginners. However some experience with (e2e) test automation and some (very) basic programming skills (also when that's not with JS/TS) will come of use. After this tutorial you will be familiar with the most common features and use cases Cypress has to offer. You will be able to setup and implement a sustainable test automation framework containing end-to-end (e2e), API and component testing using Cypress. By the end of the day you will be ready to share your skill and knowledge with your organisation or team.
Test automation frameworks and projects do not always have the best reputation. When looking at such projects we often come across many of the same issues. Typically we can divide these issues into methodical issues (soft) such as a undefined test (automation) strategy, and technical issues (hard) such as poor maintainability and flakiness.
This workshop aims to address both issues. First we will have a look at how a well defined test automation strategy (using the test-pyramid and alike figures) can actually help a team with their test planning (how and what are we testing?) during refinements by clarifying test responsibilities and roles.
Secondly we will learn how to make a test automation project effective, efficient and maintainable for an entire team (not just the TA engineer) to collaborate on.
We will start learning Cypress with a exercise to setup (and run) a 'first test' (according to our strategy). We will be testing public app (SUT) that is hosted for the sake of this workshop (to avoid installation issues and loose time over this).
Next we will improve upon our project with an assignments/exercises on using fixtures and hooks to make tests less dependent and more effective.
After that wil will thoroughly cover best-practices for selector and locators to simulate an end-user as best we can and explore some dangerous pitfalls.
Finally we will implement a popular design pattern called the 'Page object model' to improve maintainability. Then we improve upon the POM by adding interactions to it. For the fast learner we have a variation (bonus) where we add 'composition' (replacing interactions) which makes it even more DRY and maintainable.
1. How to set up an effective TA framework using Cypress
2. 2 Ways to implement the Page object model (basic: only abstracting selector/locators, advanced: make use of 'composition')
3. Best practice selector- and locator strategies
All participants are required to bring their own laptop with a (local) installation of the latest NodeJS and a working internet connection.
No docker (compose) required. We will work with a publicly hosted SUT.
No hardcore JS/TS skill are required. Just some (very) basic programming (in any language) will be sufficient to keep up during the workshop. There is little JS/TS syntax that would cause complexity.
A decision is often rated by the level of significance - positive or negative - of the actual outcome. However decision-makers (groups or individuals) do not control everything that influences that outcome. The only thing we can control is the process of decision making it self. So let's control that!
Did you know that ALL (!) decisions are driven by emotions rather then logic?! No exceptions!… So doesn’t that contradict the idea of ‘data-driven’ decision making?…Well, the answer is both ‘yes’ and ‘no’.
During this workshop you will be taught how to break down any decision (small or big) into properties and small bits that we can quantify and estimate (based on emotions, yes..). Then in the final stages of our decision-making-process we will bring all of these quantified parts back together (through models) to create a grand total overview!
This workshop is full of hands-on exercises. Sure we'll cover the theory and best-practices, but the focus is for you to go home with not just a few tools in the bag (such as the Pugh- and AHP-matrix), but most of all the skill to apply them the next day!
Choosing an architectural style and/or design pattern(s) for your new project can be a daunting task. There is an ocean of design patterns and best practices out there and never enough time research them all.
During this talk we will explain how to use your (defined) ‘quality attributes’ as input for a decision making model on software architecture that is called ‘pattern driven design’. By using this model you don’t have to research all the different patterns/architectures out there nowadays. It has already been done for you (by University of Utrecht).
When leaving the room you will never have to spend more than a day on selecting design patterns and architectural styles for you project (extension).
byte-sized talk (16 min), Target audience: Anyone who is involved in software design (at some point).
Do bugs and technical debt make you want to pull your hair out? Does your backlog never seem to shrink but only grow? Is your velocity (and roadmap) unpredictable too?
Yes? Then this a session for you!
First we'll cover the different types of technical debt. Once you can recognise them you are ready apply a few simple tactics that will help you get a hold on your technical debt that keeps pilling up whilst slowing down your delivery frequency at the same time.
During this session you'll also learn more about (data-driven) decision making (including tools/models), DevOps- and Lean principles like 'Good is good enough' or 'Decide as late as possible' and how these (attitudes) will accelerates your teams decisiveness and flow.
Join us and learn how to obtain a balanced delivery system for features, bug fixes and solving technical debt.
- DevConf Poland (2023)
- Ya!vaConf (2023)
- Conf42 DevOps (2024)
Target audience: Both engineers and non-engineers who have experienced working with agile practices like 'scrum' at some point in their career.
Technical requirements: no extra/special requirements
preferred duration: 45/50 min.
Youtube link: https://www.youtube.com/watch?v=fynUdECBKb4&list=PL8BUDiR2Y8YuD1K4rLbZMSvAlM62H6PGx&index=19
Let's talk about the elephant in the room: testing in software development isn't always a crowd favorite. But what if it didn't have to be that way?
This session is all about cracking the code to make testing not just bearable but actually kinda cool.
No, seriously. It's not just another snooze-inducing session on testing. We're unpacking practical tips and clever techniques (such as risk-based testing and property-based testing) to make testing more interesting, efficient and less of a time sink.
Join us and learn about (test design) techniques that'll turn testing into a secret weapon in your software development toolkit. Finally you will know how to answer the question “What should I (not) test?!”….
It's time to be more effective and starting doing more with less—less time testing, more time building awesome stuff!
Target audience: Developers / unit test writers
Preferred session duration: 45 - 60 min
The software- and tech industry is rapidly changing and it's an exciting time to work in this field. In the meantime many pitfalls in quality automation remain in place and are not (yet) solved through the adoption of AI and LLM's.
During this sessions we'll dive into both technical- and non-technical challenges teams get confronted with when they strive to implement a 'built-in' quality system.
We will cover issues such as 'testability', 'maintainability' and how combinations of design patterns like the 'page object model' (POM) and 'composition' will help to revive your test automation project so that everyone involved feels that it is actually 'helping' rather than slowing-down. Also I'll share some (war) stories on how I helped teams to make quality a common or shared responsibility, rather than forwarding this to a dedicated person on the team.
If you'd like to learn recognising these pitfalls in your team or organisation as well and also pick up a few strategies and (design) patterns to help you save your test automation framework from drowning, then join me here!
Working with legacy code can be a daunting task, but Test Automation could make it manageable.
By taking a slightly more pragmatic approach (rather than holding on to a traditional one) on Test Automation, we could breathe new life into legacy code and keep it running smoothly for years to come. Being pragmatic implies sometimes having to let go of best practices like upholding certain standard and metric like code- and test coverage that in some cases are just not realistic given the essence of time in a revival/survival situation.
In this talk, we'll discuss strategies like TDD (amongst other things) that, if applied with a little bit of pragmatism, are perfect for the revival of your legacy project. Also I'll give you some tips on figuring out where to start (and stop) in a 'low-coverage-situation' and how to identify the low-hanging fruit to quickly build an effective test suite to reduce the biggest risks.
Whether you're a seasoned engineer or just starting out, this talk will offer valuable tips for reviving legacy code with Test Automation. Sooner or later, you'll have to deal with legacy!
preferred session duration: 40 - 50 min
QA Automation Advocate
Gennep, The Netherlands