Presentation: TweetSoftware that Fits in Your Head

Software gets complicated fast. Most of good architecture and design practise is about trying to slow the rate at which software gets complicated. You can't stop it, it's a form of entropy. You can only slow it down and do your level best to stay on top of things.

One way to manage the mess is to maximise the likelihood that everyone knows what's going on in the codebase. This requires two things: consistency and replaceability.

Consistency implies you can make reasonable assumptions about unfamiliar parts of the application. Replaceability means you can kill code easily and replace it with something better.

Dan North argues that code should either be new enough that someone remembers writing it, or well-enough established that everyone knows how it works. It's code in that awkward middle stage, between brand new and part-of-the-furniture, that gets forgotten about and starts to smell.
If code is going to die it should die quickly. If it is going to stick around it should be stable.

In this talk, Dan describes a model for thinking about the age of code and argues for replaceability as a first class concern. He also discovers that if you optimise for both replaceability and consistency you can end up with something that looks a lot like microservices.

Presentation: TweetSoftware, Faster

Some teams are orders of magnitude more effective than others. Kent Beck famously described himself as "not a great programmer, but a good programmer with great habits". For the last few years Dan North has been working with, and observing, some very good teams with quite exceptional - and rather surprising - habits.

Are katas the best way to learn a new language? Is manual testing a waste of time? Is copy-and-paste always evil? Is the customer always right? In this talk Dan introduces the idea of delivery patterns - patterns of effective behaviour in delivery teams - and describes some of the more unusual but effective patterns he's been collecting. These are not patterns for beginners, but then again, Dan argues that patterns aren't for beginners anyway.

Prerequisite attendee experience level: advanced

Workshop: Testing, Faster Tweet

Testing Faster is a workshop exploring the principles and practises of agile testing. Taught in a dynamic, interactive and engaging style, there are no slides or handouts. Instead participants work together in small groups to reinforce the training and make it relevant to their own context.

Outline

• Test Strategy—reasoning about what, where and when to test
• Test Design—reasoning about how to test
• BDD—understanding its relationship to testing and automation
• Automation—when, where to automate, and where not to
• Designing for Testability—how test thinking can inform design, development and deployment

Learning outcomes
After completing the class, participants will be better able to:

• identify and apply a number of testing techniques and methods.
• make design choices that promote testability
• understand and implement non-functional testing strategies for e.g. performance and resilience testing.
• make suitable cost benefit trade-offs for testing throughout the application lifecycle.
• recognise the diminishing return of different testing techniques and avoiding over-testing.
• apply consistent testing techniques within and across applications.
• understand and develop the role of test analysts.
• introduce instrumentation, analytics and telemetry into their development approach.
• classify testing techniques by various characteristics and describe their respective merits and trade-offs.
• apply a risk-based approach to recognising missing or inadequate testing.
• apply feature management techniques like semantic versioning and feature hiding.

Workshop seats are limited.