Our Guests for the Technical Agility track

Programmers need automated tests to avoid wasting huge amounts of time manually checking and fixing code. But automated tests also tend to waste a huge amount of time:

• Flaky tests fail randomly.
• End-to-end tests run slowly.
• Mock-heavy tests can be hard to understand, lock in implementation, or only test themselves.

People use design techniques such as Hexagonal Architecture to reduce these problems, but they require expensive architectural changes and often leave infrastructure untested. (Infrastructure is the code that talks to external systems or state.)

In this hands-on coding course, James Shore will show you another way. You'll learn how to write tests that are fast, reliable, fully test infrastructure, and don't require architectural changes. Better yet, they're 100% compatible with your existing code and tests. You can start using them immediately, even in a legacy codebase.

Learn about:

• Terminology: narrow vs. broad tests; interaction-based vs. state-based tests; sociable vs. solitary tests.
• Understanding Nullables, configurable responses, behavior simulation, and output tracking.
• Comparing and contrasting broad tests, interaction-based tests, and sociable tests.
• Designing tests for clarity.
• Writing high-level infrastructure wrappers (also known as "Adapters" or "Gateways")
• Using Nullable low-level infrastructure to test high-level infrastructure
• Implementing output tracking
• Designing infrastructure wrappers; encapsulation; composition/decomposition

All this and how to build and test a web page controller that calls an external service, and an infrastructure wrapper for an external service.

As organizations become more digital and departmentalized, connecting everyone around the same Vision and around Customer Needs is more critical than ever. More than just delivering the right thing to users, much work also calls for consideration when aligning every part (developer teams, management teams, marketing, operations ...) to achieve the common goal: delighting the Customer.

More than just that, as the Human person is the most complex being in the world, organizations that are made of those have twice (or an infinite times!) these complexity factors. The way people communicate and the level of detail they need to fulfil different tasks varies, so getting everyone to speak the same language is a challenge. However, how can these different teams communicate better and more clearly?

Jon Kern has something to say about that! The Agile Manifesto co-author will discuss the foundations that he considers to be necessary for producing a digital product, aligned with both the Customer needs and the Vision of managers, as everything starts with the approach software development teams have when getting their "hands dirty".

How can multiple teams work together on a single product? The common wisdom is to carefully align teams and responsibilities to create autonomous teams. But, invariably, this approach eventually runs into cross-team bottlenecks, challenges aligning responsibilities to teams, and difficulties creating cross-functional teams.

Fluid Scaling Technology, or FAST, is an innovative new approach that solves these problems. It uses frequent team self-selection to prevent bottlenecks, share knowledge amongst teams, and ensure the right people are working on the right things. It’s simple and lightweight.

Join James Shore as he shares his experiences with scaling Agile—first with traditional approaches, and more recently with FAST. Learn what works, what doesn’t, and how you can try FAST in your organization.