Do you like some of what you find in the common scaling frameworks but don't buy-in to everything? Then, go to the essence!
This session will present and share a set of principles for scaling, which you can use to roll-your-own approach or properly contextualise the usage of an existing framework such as LeSS, Scrum@Scale or Nexus.

Unlike other scaling approaches, these guidelines are non-prescriptive and recognise the value of elements in many scaling frameworks.

Target Audience: Managers, Decision Makers, Agile Coaches
Prerequisites: Basic understanding of agile. Having been exposed to agile at scale projects is a plus
Level: Advanced

Extended Abstract:
ScaleAgility is a set of principles to create sound scaled organisations.
Devised by a group of five trainers and coaches with a total of more than 70 years of experience in large-scale agile implementations, these principles aim to expose the tensions inherent in any organisational development initiative and provide guidance to discuss and develop strategies and tactics for transforming a company.
In this workshop we will discuss:

1. A set of general principles to consider when creating large-scale agile organisations
2. How properly defining products and the way the product definition evolves are fundamental for large-scale agility
3. A path for Teams to evolve from localised responsibility to feature Teams
4. How the Leadership should accompany the change

This highly interactive workshop is all about software architecture - with Spring Boot, the Java microservice framework. Using an example application, we will discuss and try out the following topics in code:

• REST API design
• Hexagonal architecture
• Bean validation
• Single sign-on with Keycloak
• Role-based security
• Optimistic locking with ETags
• OWASP dependency check
• Structured JSON Logging
• Error handling
• Integration tests with Cucumber
• Architecture tests with ArchUnit
• Local deployment with Docker
• Reverse proxy with NGINX

Please install the following software before the workshop (if not already available):

• Java 17+
• Gradle 7.3+
• Docker 19+
• git
• an IDE of your choice (like IntelliJ IDEA)

On Windows, we also highly recommend you install the Windows Subsystem for Linux 2+.

Target Audience: Software Architects, Software Engineers, Java Developers
Prerequisites: Basic knowledge in Java, Interest in software architecture
Level: Advanced

Extended Abstract:
Prerequisites:
This workshop is highly interactive. You will benefit greatly from trying it out for yourself as well.
Please install the following software before the workshop (if not already available):

• Java 17+
• Gradle 7.3+
• Docker 19+
• git
• an IDE of your choice (like IntelliJ IDEA)

On Windows, we also highly recommend you install the Windows Subsystem for Linux 2+.

The example application "Chameleon" that will be used in this workshop has been designed as an educational example project for learning the basics of the Spring Boot ecosystem. But project "Chameleon" tries to be more than just a simple "hello world". It has all the needed parts in place to be as close to a "real world" production-ready software as possible.

Project "Chameleon" currently contains the following features:

General

• Backend with Spring Boot
• Yaml configuration file
• Hexagonal architecture
• Build with Gradle
• Local deployment with Docker
• Reverse proxy with NGINX

REST API

• Definition of RestController with GET, POST, DELETE and PATCH
• Description of REST API with OpenAPI
• Swagger UI
• Dtos
• Model mapper
• Bean validation
• Global error handler
• Local error handler
• Request ids
• Optimistic locking with ETags

Database

• Storage in relational database with PostgreSQL
• JPA, JpaRepository (Spring Data)
• Database migration with Flyway

Security

• Integration of SSO (single sign-on) with Keycloak
• Role-based security (JSR250)
• OWASP dependency check

Logging

• JSON logging
• Structured logging
• Logging of request ids
• Logging of user and roles

Testing

• Unit tests with JUnit 5
• Assertions with Google Truth
• Architectural unit tests with ArchUnit
• Coverage report of unit tests with JaCoCo
• Integration tests with Cucumber

Today we must deal with shorter time-to-market, increasing complexity and more agility while keeping quality and other key system properties high.
To address these challenges the right balance in testing w.r.t. independence, timing, automation, and formality is critical but often not explicitly tackled.

Therefore, in this interactive tutorial we reflect on our current approach on balancing testing, investigate and discuss needed strategies, tactics, and practices, and share experiences to improve and sustain our testing approaches!

Max. number of participants: 40

Target Audience: Test Architects, Test Engineers, Product Owners, Quality Managers, Software Architects, Developers
Prerequisites: Basic knowledge about testing and quality engineering
Level: Advanced

Extended Abstract:
Today we must deal with shorter time-to-market, increasing complexity and more agility while keeping quality and other key system properties high. Our test systems increase in size, volume, flexibility, velocity, complexity, and unpredictability. Additionally, digitalization requires more than just a face lift in testing.

To address these challenges the right balance in testing w.r.t. independence, timing, automation, and formality is critical but often not explicitly tackled. Therefore, in this interactive tutorial we reflect on our current approach on balancing testing, investigate and discuss needed strategies, tactics, and practices in different areas, and share experiences and lessons learned to improve and sustain our testing approaches!

The following areas in testing are covered w.r.t. their appropriate balancing:

• Level of independence – independent vs. fully integrated with development
• Timing – too early vs. too late
• Degree of automation – automated vs. manual
• Formality – formal vs. informal, scripted vs. exploratory
• Test case design – structured vs. experience-based, black-box vs. white-box

Approval testing is a technique that helps you to get a difficult codebase under test and begin to control your technical debt. Approval testing works best on larger pieces of code where you want to test for multiple things and interpreting failures is challenging.

In this hands-on session we'll introduce a commonly-used Approval testing tool for Java and through hands-on exercises learn to get control of some example code. The same tool is also available for many other programming languages, see https://approvaltests.com/

Bring a laptop.
Max. number of participants: 30

Target Audience: Developers, Architects
Prerequisites: Basic knowledge of Java and unit testing, bring a laptop
Level: Basic

Extended Abstract:

Introducing Approval Testing (55 minutes)

• Code Review: examine existing test case, discuss strengths & weaknesses
• Demonstration: Convert an assertion-based test to use Approval testing
• Hands-on exercise: Add some tests using Approvals.Java.

Break (5 minutes)

Approval Test Design (50 minutes)

• Presentation: Approval testing characteristics and design patterns
• Exercise: Using the default XML printer with Approvals.Java
• Demonstration: Using scrubbing with an XML printer
• Discussion: when to print, when to scrub

Printer Design (30 minutes)

• Exercise: Designing a printer for a domain object
• Presentation: Case studies
• Q&A (10 minutes)

Join this tutorial to experiment with a self-reflection process, designed to bring balance into your own development journey.

Rooted in professional coaching practices from Co-Active Coaching, connected with several Liberating Structures, and inspired by ideas from Emotional Agility, this session will help you clarify your goals and aspirations as well as find the right balance for 2023.

Why do you do what you do? What’s important to you about it? What’s next?
Discover answers to these questions in this innovative and impactful tutorial.

Max. number of participants: 50

Target Audience: Architects, Developers, Technical Leaders, Managers, Agile Coaches
Prerequisites: None
Level: Basic

Extended Abstract:
When was the last time you had a chance to reflect on your career path, your goals and learning aspirations for the upcoming year?
This tutorial will be an opportunity to do this reflection in a very meaningful and innovative way. Rooted in professional coaching practices from Co-Active Coaching, connected with several Liberating Structures, inspired by ideas from Emotional Agility and Positive Intelligence, this session will help you clarify your goals and aspirations as well as find the right balance for 2023. Should you continue developing your technical mastery? Should you spend more time growing your leadership skills? What could you take on, if you were brave enough? How to find the time?

You will explore these and many other questions! Working individually and in small groups, we will start by clarifying your own core values. We will then explore what’s on your plate today, and what you are hoping to gain in 2023 with Ecocyce Planning Liberating Structure. We will explore in depth your Ecocycle traps: good ideas that you are not moving forward with as well as skills and practices that are no longer relevant for your self-actualisation.

Next, you will practice to apply your core values as a filter to activities and aspirations on your Ecocycle. You will seek patterns, and take a systemic view with W3 structure, gaining new insights and re-evaluating your Ecocycle. Next, in a silent brainstorming, you will come up with a list of actions you would (and would not) take in 2023, if you were 25 time bolder. Once again, you will apply your core values as a filter to find the most impactful actions on your list. We will wrap up the tutorial with 15% Solutions Liberating Structure, asking you to make a choice of the immediate next steps toward more impact and more balance on your development journey.

This session will take you deep into what really matters for you as a professional and as a human being. Learn from the case studies of applying this framework in individual coaching, team workshops and leadership coaching. Be prepared to be surprised by your own insights and Aha! Moments of other session participants.

How often have you heard that “Yes this is important, but we don’t have the capacity right now” or “sure let’s put it in the backlog”?

At least 1 in 5 people in the UK have a long-term illness, impairment or disability. Many more have a temporary disability. A recent study found that 4 in 10 local council homepages failed basic tests for accessibility.
Bring a laptop.

Max. number of participants: 20

Target Audience: Everyone
Prerequisites: None
Level: Basic

Extended Abstract:
How often have you heard that “Yes this is important, but we don’t have the capacity right now” or “sure let’s put it in the backlog”?
This is something we should not brush off or take lightly. Accessibility testing is vital especially when your product is a user facing application.
We need to be socially aware as a team and build quality towards our product with making it more accessible.

At least 1 in 5 people in the UK have a long-term illness, impairment or disability. Many more have a temporary disability. A recent study found that 4 in 10 local council homepages failed basic tests for accessibility.

This is quite vital and the sooner we as testers can advocate this into our teams, we make our product more accessible, reduce the risk of bad product reviews, reputation and also be more socially aware. Let's shift left and make accessibility testing built-in our teams.

1. create a checklist
2. look at some plugging (wave, lighthouse, arc toolkit, developer tools)
3. Screen readers (mac/windows inbuilt)
4. Have a healthy discussion on what they have learnt in the session and how can we bring accessibility sooner in an SDLC?