Note: this is a past event Check out the current event!

Tuesday & Wednesday — Workshop Day 1 & 2

Crafting Code (2 days)

Clean code
Tuesday+Wednesday 9:00 - 17:00


This course is designed to help developers write well-crafted code—code that is clean, testable, maintainable, and an expression of the business domain. The course is entirely hands-on, designed to teach developers practical techniques they can immediately apply to real-world projects.

Why attend?

Software Craftsmanship is at the heart of this course. Throughout, you will learn about the Software Craftsmanship attitude to development and how to apply it to your workplace.

Writing Clean Code is difficult. Cleaning existing code, even more so. You should attend if you want to:

  • Write clean code that is easy to understand and maintain
  • Become more proficient in Test-Driven Development (TDD): using tests to design and build your code base
  • Focus your tests and production code according to business requirements using Outside-In TDD (a.k.a. the London School of TDD)

Clean code necessitates good design. In the process of driving your code through tests, you will learn how to:
  • Understand design principles that lead to clean code
  • Avoid over-engineering and large rewrites by incrementally evolving your design using tests

Once you have an understanding of the principles at work, we will apply them to Legacy Code to help you gain confidence in improving legacy projects through testing, refactoring and redesigning.

  • TDD lifecycle and the Outside-In style of TDD
  • Writing unit tests that express intent, not implementation
  • Using unit tests as a tool to drive good design
  • Expressive code
  • Testing and refactoring Legacy Code
The course is fully hands-on and developers will be writing a lot of code.

Software developers that:
  • are familiar with at least one Object-Oriented language
  • are able to understand Java or C#
  • legacy code exercise will be done in one of the following languages: Java, C#, PHP, Scala, or C++
  • can write and execute unit tests using a framework (such as JUnit, NUnit, etc.)
  • have a basic understanding of mock objects

Developers must:
  • bring their own laptops
  • have a development environment consisting of: their favourite Object-Oriented language, a unit test framework, a mocking library
  • be able to create projects, build source code and run test cases in their development environment
In addition, a distributed version-control system such as Git is desirable.

Tuesday — Workshop Day 1


Micorservices Architecture
Tuesday 9:00 - 17:00

This tutorial goes into depth on the business need for speed that leads to microservices and the characteristics of existing microservice architectures. In addition, there will be a hands-on exercise to model your existing architecture, a future state, and the step by step migration to get there.

The audience is developers, architects, technical leaders, operations engineers, and anybody interested in the design and architecture of services and components. As part of this training, attendees get hands-on in simulating their own microservice architectures, using the open source spigo/simianviz tool.

While no experience of microservices or SOA is necessary, it would be useful. Moreover, some awareness of cloud architectures, web services, and DevOps practices would also help.

Computer prerequisites
A laptop where you have admin rights to install software and the ability to sync to Github to get the code and contribute changes. We will use the Go language runtime (currently version 1.4.2). Windows, MacOSX, and Linux are supported.

Modern Infrastructure With Terraform & Consul

WITH Seth Vargo
Terraform Cloud DevOps Infrastructure as Code
Tuesday 9:00 - 17:00

Terraform is a fantastic tool for provisioning infrastructure, but with such a broad range of responsibilities, it is easy to become overwhelmed with the API, terminology, and workflow. This workshop will cover the basics of Terraform. Beginning with a quick lecture-style introduction to Terraform, we will quickly dive deep into the tool, following the fictitious evolution of a startup as our guide. Not only will this workshop discuss various components of Terraform, but attendees will also understand why and how they might make infrastructure changes with Terraform. Now that our infrastructure is provisioned, how can we connect the various components? With one or two machines, it is easy to point IP addresses, but what happens when we have thousands? We will use Terraform to create a Consul cluster and explore service discovery and health monitoring with Consul. Depending on the time remaining, we will explore the complex problems of secret management using Vault.

Key takeaways:

  • Provision and manage infrastructure with Terraform
  • Understand the evolution of applications as they relate to scale and operations
  • Explore service discovery and service discovery techniques

  • Participants should have an active AWS account with permissions to create and manage resources
  • Participants should have the latest version of Terraform installed locally
  • Participants should have administrator privileges on their laptop or the ability to escalate privilege easily
  • Participants should have a modern Internet browser such as Firefox, Chrome, or Safari (not Internet Explorer)
  • Participants should have some familiarity with running infrastructure

You can view the materials here:, and that will also need to be distributed to the attendees a few days in advance, since there is some setup required on their part.

Java 8 Lambda Expressions & Streams

Java 8 Lambda Streams Performance
Tuesday 9:00 - 17:00

Java 8 is the largest update to Java in its history. Some of the best ideas from functional programming are migrating their way into Java 8. This intense one day workshop is a hands-on lab session comprising slides, quizzes, live coding and unit test exercises which covers important Java 8 topics.

Why take this tutorial?
Java 8 encourages a different style of programming that: - lets you cope for requirement changes (less engineering efforts!) - lets you take advantages of multi-core architecture easily (faster code!) - lets you process large collections with SQL-like operations (do more in less time!) - lets you write more concise code (better readability & maintainability!)

At the end of the workshop you will be able to use the most important Java 8 features to write easier to read, more flexible code that scales to multicore.

Topics covered include:
Lambdas & Streams

  • Behaviour Parameterisation
  • What is a lambda?
  • Method references
  • Collection Processing
  • Stream operations and patterns
  • Stream Optimisation
Collectors & Data Parallelism
  • Grouping and partitioning
  • Collection Operations
  • Arithmetic collectors
  • Advanced Queries
  • What is Data Parallelism?
  • Parallelising your streams
  • Decomposition performance

Lean Poker

Continuous Delivery Coding challenge Agile Lean Web service
Tuesday 9:00 - 17:00

Lean Poker is this: you and a small group of strangers are going to develop a bot in a language of your choice, that plays poker against other bots. (Don't worry if you don't know poker, we will teach you.) All you need to do is write a function that takes a data structure containing cards and bets your bot sees during the game, and return a single number: the amount you are willing to bet at that point.

Now here is the catch: even before you start coding the bots play a round in a matter of seconds, and if your bot wins you get points. If it comes second, you get less points. Otherwise you get nothing. The next minute another game plays, and another one, and another one… that goes on all day long, while you and your friends are desperately hacking away on the code, and keep deploying, deploying, and deploying. Don’t worry about the deployment pipeline, that’s already set up for you.

During this pretty intense day you will sometimes be cheering for your bot to take over, you will be deploying desperately to change the course of events when your bot keeps losing, but even more importantly you will learn how to create as much value as you can in a short period of time, while you are mostly just having fun.

Please check out for more information.

Stop Herding, Start Leading

Team Leadership Craft
Tuesday 9:00 - 17:00

When you lead a software team, everyone benefits from setting firm foundations. You will find that developers on your team work better together with a clear vision and sense of purpose. With a firm foundation, you will be able to strike a balance between innovation and consistency on technical architecture. All this is underpinned by a streamlined approach to daily work, where the team can see progress and improve practical skills on the way.

When you build firm foundations, your team will be able to handle the changes that a fast-paced business throws down. When you have the key to individual developer motivation, conflicts become easier to resolve and you will find team discussion inspires improvement. In order to inspire confidence from others, you need a solid approach, trust springs from your skills so you need to keep them sharp.

In this workshop, you will acquire a new framework that helps set up a team for success maintaining momentum on delivering business value. The skills we will cover can be useful at any point in the life of a project. Come to this workshop if you aspire to lead software teams to deliver great products while finding satisfaction in their craft.

We will cover a range of topics through presentation and practical exercises, you will have the opportunity to try all the techniques explained in the workshop. We will talk about real scenarios that you are likely to face and ways that you can lead your team through them. As you will learn, the secret is to build firm foundations for your technical leadership.

Prerequisites: The only prerequisite for this workshop is some experience working in software development and a desire to lead teams to success. This workshop is suitable for most conference attendees whether they are senior developers, technical managers, and architects.

Friction Lab

Friction Risk Journey Full Stack Teams
Tuesday 9:00 - 17:00

Friction. Starts fires. Stops airplanes. Gives traction. Saps energy. A small bit of friction is unavoidable to gain traction and overcome inertia. A large dose of friction slows everything down, annoying customers and eating away at profits. This lab looks at the four most common sources of friction in digital systems and what to do about them:

  • Friction in the Journey
  • Friction in the Process
  • Friction in the Code
  • Friction in the Flow

You will Discover:
  • The main causes of friction in the consumer journey
  • How cognitive biases affect our teams as well as our customers
  • A reference process for modern digital systems
  • How to make and keep reliable promises
  • How savvy governments deliver digital services
  • Critical attributes of successful large-scale systems
  • The best way to keep complex systems stable and reliable
  • Why flow efficiency trumps resource efficiency
  • Six ways to increase flow efficiency

More Information: Essay on Friction.

Code Smells - Developing Design Sense for your Code

Code smells
Tuesday 9:00 - 17:00

\"In order to make delicious food, you must eat delicious need to develop a palate capable of discerning good and bad. Without good taste, you can't make good food.\" - Jiro Ono (World’s Best Sushi Chef)

The same is true for great code. If we want to make great code we need a refined palate for what great code looks like. We need to look at code and develop a sense for it’s properties and smells. Sadly this is rarely ever done. Programmers are expected to just “know” what is good and what is bad with ever getting a chance to develop and curate an aesthetic sense. Worse, code is rarely looked at unless it is causing us problems so we are expected to be gourmets while spending our time eating at McDonalds.

Come work on your sense of code. We will look at many snippets to compare and contrast different aspects of what good code is.

Building highly scalable web apps with Go

Golang Web Backend
Tuesday 9:00 - 17:00

During this workshop you will build a web application from scratch using Go to build the backend and some HTML, CSS, JS on the frontend, of course.

You will gets a hands on experience implementing REST APIs with and without any frameworks. We will also use the built-in concurrency features of Go to make the app faster.

We will also add features to the app using some of the services available on App Engine:

  • List text here- datastore to store data in a non relational database.
  • Memcache to cache and access data faster.
  • Task queues to schedule tasks to be executed later.
  • Mail to send and receive emails.

The app will then be deployed on top of Google App Engine, which provides a free tier, so attendees will go through the whole process from inception of an app to deployment and monitoring.

Awesome Postmortems

Postmortem Learning Failure
Tuesday 9:00 - 17:00

Failure is inevitable. Success is unpredictable. Both failure and success are also tremendous learning opportunities. A postmortem, conducted in an skillful way, is one of the best ways to learn from both failures and successes. Postmortems help us identify and address areas of fragility within systems and organizations, making both more resilient.

In this highly-rated, practical, hands-on session, you’ll learn the theory and, most important, get to practice conducting awesome postmortems, including:

  • How to set the context, and go beyond blame
  • What data to collect before the postmortem and how to present it in the most useful way
  • How to facilitate charged conversations during high-stakes postmortems
  • Finding the real root cause of any failure or success (yes, there is such a thing!)
  • Learning in complex, adaptive systems
  • The new view of “human error”
  • How to recognize and mitigate the effects of cognitive biases
  • Writing up postmortem results (for internal and external audiences)
  • Harnessing prospective hindsight to identify risks and reduce the possibility of future failures

Anyone tasked with facilitating postmortems, retrospectives or learning reviews. And anyone wishing to learn more (and better) from failure and success. Anyone interested in building learning organizations.



Testing, Faster

WITH Dan North
Testing Patterns Techniques Agile
Tuesday 9:00 - 17:00

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.

  • Test Strategy
  • Test Design
  • BDD
  • Designing for Testability

Wednesday — Workshop Day 2

Software, Faster

WITH Dan North
Patterns Techniques Delivery Advanced Effective
Wednesday 9:00 - 17:00

Formerly Accelerated Agile

Great software professionals build better software faster. Agile methods, continuous delivery and software craftsmanship helped speed up delivery from years to months or even weeks, but then what?

Some teams are able to deliver software at a speed of change like you have never seen before, delivering quality software in days or even hours, again and again. So what is keeping the rest of us from doing so? Now is the time to go from months to minutes, to rethink the way we organize and improve our software development and delivery process.

Software, Faster is for people who believe it can be done. People who feel themselves limited by current Agile, CD and Craftsmanship thinking. People who want to go back to basics and uncover new, simpler ways to deliver great software.

Are you a seasoned agile developer who is frustrated at how slow your “hyper-performing” process feels? Are you suffering with an unwieldy feature backlog, the pantomime of estimation, the card wall where cards go to die, the efforts to automate where it obviously isn’t adding anything? Are you fed up with the artificial commitment of sprints and the unwelcome surprises that still seem to derail your projects?

Software, Faster brings agile principles into the 21st century. You will learn new techniques that both enhance and replace existing agile practices, some of which are counter-intuitive and many which are completely counter to current “agile” doctrine. Using a mixture of discussion, instruction and exploration you will start to think differently about design, architecture, development and testing, operations, automation and team dynamics, as well as working with legacy systems and integrating with third parties.

What you will learn:

  • How to challenge the received wisdom of established Agile methods
  • How to design and architect for rapid and sustainable delivery
  • Why understanding risk and embracing uncertainty are at the heart of faster delivery
  • How to manage build, release and operations
  • How systems thinking can help you plan effectively and estimate accurately
  • How to identify and reduce gaps in your testing strategy
  • How to engage with legacy systems and integrating with third parties
  • How to manage different levels of skill and experience within a team

Specification by Example

Wednesday 9:00 - 17:00

Specification by Example (SBE) is the corner-stone of a successful software quality strategy in agile and lean processes. In this workshop we explore the process patterns that successful teams use to implement SBE, and give you practical experience of how to apply the technique to bridge the communication gap between stakeholders and implementation teams. You will be learning the tips and tricks that successful teams use to build quality into software from the start, as well as collaborative techniques to help design, develop and deliver systems fit for business purpose.

The workshop is aimed at product owners, testers, developers and business analysts. Through a series of facilitated exercises and group discussion, you will learn:

  • How to overcome problems of incomplete, unclear or ambiguous requirements
  • How to illustrate specifications with concrete examples to create a single source of truth for testing and development
  • Tips for how to run specification workshops to maximise collaboration and efficiency
  • Identifying the characteristics of good specifications and examples
  • How to create a living documentation system to add value to your process long-term

This is a hands-on tutorial, using group exercises and collaborative learning techniques to help you go beyond the theory, and give you insights into the subtleties for success and traps to avoid when creating agile specifications and testable examples of acceptance criteria. The secret for success with SBE is to be able to apply the concepts in practice – you will learn from an experienced coach the techniques for succeeding when using SBE in your own domain.

The course material is based on Gojko Adzic’s best-selling books Specification by Example and Bridging the Communication Gap, as well as Gojko and David’s new book 50 Quick Ideas to Improve your Tests.

Creative Collaboration: Tools for Teams

WITH Doc Norton
Collaboration Teamwork Decision making Agile
Wednesday 9:00 - 17:00

Even high functioning teams occasionally have a hard time making decisions or coming up with creative ideas. There are times when the conversation seems to drag on long after a decision is reached. There are times when we have too many people involved in the discussion or the wrong people involved. There are times when we're not sure who's the actual decision maker. And there are those times when we just seem to be out of synch with each other. This creative collaboration workshop provides tools that help resolve all of these issues.

Advanced Docker concepts and container orchestration

Docker Orchestration Containers Microservices
Wednesday 9:00 - 17:00

You have installed Docker, you know how to run containers, and have written Dockerfiles to build container images for your applications (or parts of your applications). Now comes the next part: connecting multiple containers together and deploying them on a cluster of Docker hosts instead of your single development machine.

This is what we will cover, along with some production-related questions: How to manage logs? Backups? Remote access? Security upgrades?

In this workshop, we will present the networking model of containers and cover how to run containerized applications spanning multiple Docker hosts. We will give recipes to implement cleanly various ops tasks including logging, backups, and more. Finally, we will discuss orchestration and scheduling. We will present solutions like Swarm and Mesos, and see some of them in action on an actual microservices architecture.

Who should attend:
Developers and system administrators who are familiar with basic Docker concepts and want to learn how to deploy Docker for real-world applications.

Take back to work:
You will know how to deploy Docker \"for real,\" and how to perform common operational tasks with containers. You will learn about patterns and best practices to scale applications with Docker and containers.

Topics include:

  • Pre-requirements
  • VM environment
  • Our sample application
  • Running the whole app on a single node
  • Finding bottlenecks
  • Scaling workers on a single node
  • Scaling HTTP on a single node
  • Connecting to containers on other hosts
  • Abstracting connection details
  • Backups
  • Logs
  • Security upgrades
  • Network traffic analysis
  • Introducing Swarm
  • Setting up our Swarm cluster
  • Running on Swarm
  • Network plumbing on Swarm
  • Last words

    Additional Materials:
    You won't need to pre-install Docker before the course; each student will be given credentials to connect to an individual virtual machine. All you need is a computer with an SSH client.

High performance organizations

WITH Jez Humble
Lean Agile Product Culture
Wednesday 9:00 - 17:00

Large organizations often struggle to leverage software to create innovative products. A number of organizational factors conspire to create obstacles to moving fast at scale, including culture, governance, and financial management, and the application of portfolio and program management strategies that do not take advantage of the unique characteristics of software.

What you will learn:
In this training we’ll discuss how to take a lean approach to developing new products and running large scale programs of work, and how to grow a culture that enables organizations to turn software into a competitive advantage.


  • Executives interested in strategy, leadership, organization culture, and good governance
  • Directors of IT, both for applications and for infrastructure and operations
  • Anyone working in program or project management, including members of the PMO
  • People in finance and accounting or in governance, regulation, and compliance who are involved in delivery.

Dealing with 'self-organisation'

Wednesday 9:00 - 17:00

Self-organisation is one of the most misunderstood concepts used in agile practice. If people really understood the dynamics of self-organising systems, they most probably would avoid trying to use it. Instead, they (mis-)apply some ideas, close their eyes, wish real hard, hope that magic happens, and then use the term “unintended consequences” to describe the result.

In spite of this fact, the ideal of the “self-organising team” is fundamental to Agile methods. Agile coaches are constantly challenged with how to motivate / persuade / trick their teams into self-organising and doing things, without telling them what to do, but there is very little information or training on this topic. Allowing a team to self-organise along the lines of \"oh well, they're all adults, they'll figure it out\" is just as irresponsible as reverting to the command-and control school of management. So, how should one go about it?

The goal of this workshop is to provide you with both the answers to that question, and with the tools you need to do the job. In this workshop, we’ll explore what self-organisation actually is and why teams don’t self-organise, and we’ll discuss what self-organisation will do to and for your teams. You’ll then learn practical techniques from social complexity science and social psychology that will help you achieve the benefits of self-organisation without suffering the unintended consequences of it.

Taming microservices with Kubernetes

Micorservices Kubernetes
Wednesday 9:00 - 17:00

Materials or downloads needed in advance
Google Compute Engine account, a laptop, working SSH client, and GitHub account.

Linux containers are only part of the puzzle when designing large scale infrastructure for microservices. First you’ll need a host to run your containers, as the OS is still a requirement. Next you’ll need to configure your containers and deploy them in a way that utilizes your resources efficiently. When that’s all done, you’ll need a way for the services running inside your containers to announce and discover each other. Oh and you need to do all of that fast; manual processes don’t work at scale. A tall order no doubt, but Kubernetes has you covered.

After attending this tutorial you’ll know how to:

  • Provision a small Kubernetes cluster
  • Package your applications as Linux containers
  • Manage application configurations with etcd
  • Implement service discovery and keep your sanity
  • Deploy and manage Linux containers with Kubernetes

Product Discovery Workshop: How To Create Products Customers Love

Process of Software Build Something That Matters Keys To Success
Wednesday 9:00 - 17:00
Hotel Parlament

Who is this for?
This is a session for people responsible for leading products - product owners and product designers, startup co-founders, product managers and product architects.

What will be workshop cover?
This workshop is specifically designed for the leaders of technology-powered product organizations that want to dive deep into the Product Owner role and learn the leading edge practices from Lean Startups, Lean UX, Agile, Customer Development, Product Discovery, and Design Thinking, as well as techniques and practices from the very best technology-enabled product companies in the world. The course is designed to teach you everything you need to know to be a confident and competent product owner/product leader for products that make a difference. It will be an intense day, but my intention is to provide the single best learning opportunity in the world for aspiring product leaders.

Who will be teaching this workshop?
The workshop will be delivered personally by Marty Cagan, the founder of the Silicon Valley Product Group. Before founding the Silicon Valley Product Group to pursue his interests in helping others create successful products through his writing, speaking, investing and advising, Marty was most recently senior vice-president of product and design for eBay, where he was responsible for defining products and services for the company’s global e-commerce trading site. Prior to that Marty was an engineer for 10 years at HP Labs, and the VP Platform and Tools at Netscape Communications. Marty is the author of the book Inspired: How To Create Products Customers Love.

How to build microservices

WITH Sam Newman
Micorservices Architecture
Wednesday 9:00 - 17:00

Microservices Architecture is a concept that aims to decouple a solution by decomposing functionality into discrete services. Microservice architectures can lead to easily changeable, maintainable systems that can be more secure, performant and stable.

In this workshop, you will discover a consistent and reinforcing set of tools and practices rooted in the philosophy of small and simple; this can help you move towards a microservice architecture. Microservices are typically small systems, with single responsibilities, communicating via the web's uniform interface, installed as well-behaved operating system services. However, with these finer-grained systems come new sources of complexity.

What you will learn
During this workshop, you will understand in depth what the benefits are of finer-grained architectures, how to break apart your existing monolithic applications, and the practical concerns of managing these systems. We will discuss how to ensure your systems can be more stable, how to handle security and the additional complexity of monitoring and deployment.

    We will cover the following topics:
  • Principle-driven evolutionary architecture
  • Capability modelling and the “town planning” metaphor
  • RESTful Web integration and event-driven systems of systems
  • What microservices are (and aren't)
  • Integration techniques including cross-microservice use cases like search and reporting
  • How to handle interface version changes
  • Deployment techniques and supporting technology
  • The importance of matching your organisational structure and your architecture
  • Continuous Integration and testing of microservices

Attendees will need either a Windows or Mac machine with administrator access, and at least 10GB of free disk space for the workshop software, which will be supplied via USB. Linux may work, but we won't be able to provide additional help to make this work.