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

Felienne Hermans's talk


Tuesday & Wednesday — Workshop Day 1 & 2

Test Driven Development (2 days)

TDD unit tests refactoring BDD specification by example extreme programming java python c++ c# .net javascript
Tuesday+Wednesday 9:00 - 17:00

Test Driven development is a combination for many microskills and a fluency that allows you to solve problems while focusing on the problem instead of the microskills.
This workshop will endeavor to learn the individual skills as well as build the fuency to use these skills with the additional burden of everyday work.

general coding knowledge in either: java, c#, c++, javascript or python (examples will be in all languages). 
a laptop with language & editor. (list at the bottom)
note: this is a very active hands on workshop. Please be well rested the night before


  • Writing scenarios
  • Transforming scenarios to steps
  • Consume 1st programming
  • Using your Editor effectively
  • Verify results
  • Using Coverage
  • Seperating code
  • Removing Duplication
  • Fake it till you make it.
Consume First style TDD requires editor support. Here are the list of editor for the class. All are available for free or for a free 1 month trial.
  • java -> eclipse or intellij
  • c# -> visual studio with resharper
  • javascript -> webstorm
  • python -> pycharm 
  • c++ -> clion or visual studio with resharper

Tuesday — Workshop Day 1

Mob Programming, A Whole Team Approach

Pair Programming Mob Programming Teamwork
Tuesday 9:00 - 17:00

Mob Programming Workshop 

Mob Programming: All the brilliant people working on the same thing, at the same time, in the same place, and on the same computer.
Mob Programming is a cost-effective, collaborative and fun way to get work done together. It's a whole-team approach to development, where coding, designing, testing, and working with the "customer" (partner, Product Owner, User, etc.) is all done as a team.

Participants in this workshop experience Mob Programming and learn the mechanics of how to work together as a Mob and the techniques that make this form of development so effective.

You’ll learn how to do Mob Programming through instruction and hands-on sample project work, including user stories, prioritization, test-driven development, refactoring, and retrospectives.

Designed and facilitated by Mob Programming pioneer Woody Zuill, this workshop provides a hands-on education in the art of Mob Programming and its significant benefits for your teams.

Learning Goals
• How 5+ people can be effective working on just one thing
• Heuristics for team size
• Guidelines for successful collaboration
• Handling competing solutions and ideas to a coding problem
• Encouraging politeness and kindness of team members
• Reducing or eliminating harmful conflicts
• Mobbing Mechanics
• Tools for team coding
• Workspace setup
• How to "Amplify Learning" and take advantage of continual learning opportunities
• "Real-time" and continuous Retrospectives to reflect, tune, adjust
• The theory of why Mob Programming is effective.
• Test-Driven Development (TDD) as a team
• Working with Product Owners, Business Experts, Testers as part of the team
• Refactoring as a team
• Continuous feedback at all levels of granularity

Instruction Approach
Hands-on Exercises, Interactive Dialogues, Simulations, Videos

Example Agenda 
(the exact order of things will likely be different)
• What Is Mob Programming & The basics of how it works
• First Exercise: A Code Dojo to Introduce Basic Concepts
• Driver/Navigator teamwork Roles and Techniques
• Second Exercise: A sample project
• The Importance of Retrospectives
• Advanced Mob Programming Concepts
• Third Exercise: Expanding on the Sample Project
• Amplified Learning - How to take advantage of learning opportunities
• Resolving Conflict
• Retrospective and review

Angular for Real

WITH Bill Odom
angular typescript javascript web development spa single-page web applications web frameworks
Tuesday 9:00 - 17:00

Angular has exploded in popularity over the last few years, and for good reason. It provides a powerful approach to building web applications, and it's surprisingly easy to create a real, working application with very little effort.

Unfortunately, it's just as easy to get stuck as it is to get started. Angular is powerful, yes, but the learning curve is steep, and while it makes easy things very easy, progress beyond that early rush of success can be tough. Many developers find themselves, a few weeks (or even months) into an Angular project, wondering how things got so out of hand.

This workshop will fix that. We'll start with an overview that puts all the major pieces of Angular in context, and explains their purpose and intent. From there, we'll dive into specific tools and techniques to help you build Angular applications that are maintainable, performant, and scalable.

Specifically, we'll talk about these topics from a distinctly Angular perspective:
  • Architecture, layout, and file structure of large applications
  • What goes where, and why -- routing, services, components, and more
  • State management
  • Performance considerations
  • Testing strategies
  • Workflows, tooling, and automation
  • Future-proofing and migration (a.k.a., preparing for the inevitable)
  • Real-world style guidelines and best practices
In short, we'll cover what it takes to build complex Angular applications that are fast and robust, without losing the power and flexibility that Angular provides.

This workshop is targeted toward experienced developers. (Experience developing web applications, however, is not strictly required.)

Please bring a laptop with the following installed:

Building A Self-Sufficient System

Cluster Docker Self-healing Self-adaptation Auto-scaling Metrics Monitoring Alerting
Tuesday 9:00 - 17:00

What do we expect from a modern cluster? If a replica fails, it should be brought back up (rescheduled). If a node goes down all the services that were running inside it should be distributed among healthy nodes. Those tasks are easy to accomplish. Schedulers (Swarm, Kubernetes, Mesos/Marathon, and so on) are already doing those things for us. Many solutions provide self-healing by making sure that the system is (almost) always in the desired state.

The problem with self-healing is that it does not take into the account constant changes. The number of requests is continuously changing, errors are created, network bandwidth is fluctuating, and so on. A cluster, and services inside it, is like a living body that needs to adapt to changes continuously. Services need to be scaled and de-scaled, nodes need to be created and added to the cluster only to be removed soon after. We call that process adaptation. Even that is not the problem in itself, as long as we have an army of operators that will monitor the system and do reactive and preventive actions.

How about converting adaptation into self-adaptation? Can we remove humans from the process and make a system that is self-sufficient?

The goal of this workshop is to provide hands-on exercises that outline the steps required for a design of a self-adapting and self-healing system that will continue operating efficiently even when we are on vacations. We'll define goals and processes and explore quite a few tools (Docker, Prometheus, Alertmanager, Jenkins, AWS, and so on). The end-result of the workshop will be a base for a self-sufficient system that you'll be able to implement in your organization.


leadership teamwork creativity developer
Tuesday 9:00 - 17:00

Leadership behaviour influences more than visible, measureable results. In our rapidly changing environment, the leaders attitude toward cooperation, creativity and change, is the new key for any team to succeed.

How can a leader turn a challenging development process into a creative flow for the team? 

How can a leader support easy-to-realize, market-relevant, successful results and long-lasting team inspiration at the same time?

These are the focus questions of the 1-day workshop organized by Invention Factory (, the exclusive user of ORGANOCO method in organizational development. The method works with the deepest layers of personal and team-psychology, and opens brand-new doors to creative thinking and success. Surprising ORGANOCO viewpoints, combined with unusual team exercises and interesting self-reflections guarantee more than a memorable experience. The workshop offers efficient practical tools, that can be applied in everyday work easily.

 Leadership topics covered

  •  How to trigger team-level creativity by overcoming hidden limitations of subconscious barriers?
  •  How to move out from the mesmerizing dominance of past experiences and usual solutions?
  •  How to find and empower the approach that supports developer teams to experience work as a joyful creation?
  •  What to know about team-roles, and the subconscious, limiting mechanisms in teams?
  •  How to utilize the skills of team members for the organization the best?


The workshop is intended for

  • top level leaders and
  • team leaders.

Testing, Faster

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

Testing Faster explores the principles and practises of agile testing. The class is 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.

  • 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

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.

Data Science for Developers (Beginner)

Data Science Machine Learning Deep Learning Big Data Analytics
Tuesday 9:00 - 17:00

In this one-day beginners-level course, you will be introduced to a range of fundamental data science concepts. You will discover how to interrogate data, choose a which machine learning methods suit your problems and how to achieve results quickly. It will provide an overview of many tools and techniques. The course is focused towards developers through programming-led examples but is industry oriented. The goal is to provide you with enough knowledge to "know what you don't know" and enable you to discuss fundamental data science topics with confidence.

Who will benefit

This course is aimed towards developers, in which we will discuss a little mathematics, but focus on developing real-life algorithms in Python. One-to-one help will be provided for developers new to Python and all algorithms, frameworks and libraries used will be demonstrated by the instructor.

This is an introductory course, which is suitable for most users with limited development experience. Some experience of Python is helpful. No data science experience is expected.

What you will achieve

The day will comprise of a series of sub-hour theoretical sessions separated by practical exercises. It will cover a range of topics, but it is expected that you will be able to:

  • Discuss the differences between types of learning
  • Describe problems in a way which can be solved with Data Science
  • Understand the difference between regression and classification
  • Solve problems using regression algorithms
  • Solve problems using classification algorithms
  • Learn how to avoid overfitting and appreciate generalisation
  • Develop features within data
  • Describe how and where to obtain data

Topics covered in this training

  • How data science fits within a business context
  • Data science processes and language
  • Information and uncertainty
  • Types of learning
  • Segmentation
  • Modelling
  • Overfitting and generalisation
  • Holdout and validation techniques
  • Optimisation and simple data processing
  • Linear regression
  • Classification and clustering
  • Feature engineering
  • An in-depth practical example demonstrating the day’s concepts if time allows

Effective Communication for Practitioners

Thinking Communication Listening Influencing
Tuesday 9:00 - 17:00
Morgan Stanley

People in the software industry are trained in programming, testing, design, documentation, and requirement management. 
That makes our work very much based on blacks and whites: Does it compile? Will the test pass? Does it fulfill the requirements? 
Bits and bytes, 0s and 1s, verified or not, yes or no, right or wrong.

Communication, on the other hand, is a spectrum. We are not trained to be effective in our communication and yet much of our work requires collaboration with others.

In this workshop we want to give you a space where you can learn effective communication techniques and have time to practice. You will learn to listen, not to respond, but to hear what is actually being said. We will provide you with tools to give and receive feedback. We will help you express what you want and what you need.

We want to inspire you to have the courage to be yourself as you communicate in an effective manner.

The morning is focused on listening. The afternoon is focused on stating what you want and feedback.
The day is a series of the following: a bit of information, practice in pairs or triads, de-brief and discussion with the group.

Making Agile Work for You

agile, Scrum, Kanban, Lean
Tuesday 9:00 - 17:00

Learn how to apply agile practices to develop the right products, deliver faster, increase quality, and become a happy high-performing team!

Many teams are adopting an agile way of working with Scrum, Kanban, XP, Lean, or any other agile framework. Their expectation is that it will help them to better serve the IT needs of their stakeholders and to develop products that satisfy their customer’s needs. Unfortunately, it doesn’t always work that way.

If your team is

  • finding it difficult to agree and decide with stakeholders on what to deliver when
  • not delivering working software every sprint or not able to finish user stories within reasonable time
  • finding it hard to understand what your customers actually need and unsure if you are delivering value to them
  • having difficulties communicating and working together as a self-organized team
  • feeling micromanaged and not empowered to decide and take control of their own journey
  • doing agile/Scrum/Kanban rituals but feeling that they are not always helpful
  • not getting good actions out of your retrospective or actions not being done

then this is the workshop for you!

Applying agile to make it work for your team isn’t easy. But it can be done!

Making Agile Work for You

In the workshop Making Agile Work for You you will experience agile practices that you can apply in your teams:

  • Practice how you can effectively tailor agile for planning your work, doing daily stand-ups with Scrum/Kanban boards, gathering feedback with product reviews/demos, and improving your way of working with agile retrospectives.
  • Learn how to apply agile practices with an agile mindset.
  • Increase your ability to pick those practices that help you to do a better job and collaborate better with your stakeholders.

The workshop is loaded with examples and suggestions to help you become more agile and lean.


This workshop is intended for:

  • Technical (team) leaders and Scrum masters
  • (Senior) Developers and Tester
  • Product Owners and Project/Line Managers
  • Stakeholders working with agile teams
  • Agile and Lean Coaches
  • Anybody who is supporting teams in agile transformations

The practices in this workshop will help you to develop the right products for your business and customers, reduce your delivery time, increase the quality of your software products, and become a happy high performing team.


What will you get out of this workshop:

  • Practice working with Agile and Scrum/Kanban: planning, daily stand-ups, product reviews and retrospectives
  • Get ideas for improving collaboration and communication with stakeholders to deliver more value
  • Find out how to deal effectively with impediments to take control and truly become self-organized
  • Learn tips and tricks to improve your agile way of working
  • Get advice on selecting and applying agile (Scrum, Kanban, XP, Lean) practices effectively for you


“The workshop Getting More out of Agile and Lean was really interesting. I specially liked the product owner and team exercise, the impediment game and the 1-word retrospective that we did. I learned when and how I can use them in my daily work.”

Bill Souliotis – Manager Software Research & Development Graphics User Interface at BETA CAE Systems

“I’d like to thank you again for your excellent workshop. It was fun and I already started using some of the ideas with my team. The change is definitely notable.”

Liran Ben-Porat, qSpark LTD

“Nice to join a workshop in which the attendees and teacher actually have profound hands-on experience with agile.”
“Immersive, good choice of subjects, well led.”
“A lot of examples.”
“Good useful interactions and learning from other participants.”

Attendees from the GOTO Amsterdam workshop

“I attended Ben’s workshop in Athens (Getting More out of Agile and Lean) and I can highly recommend it to all professionals that are serious about Scrum and about applying agile processes in real-world problems of software development. Especially for Product Owners and for Scrum Masters, this training will help you and your organisation evolve to the next level. Thank you, Ben!”

Konstantinos Vasileiou – Certified Product Owner | Senior Business Analyst

Code As A Crime Scene: Fix Technical Debt with Behavioural Code Analysis

Technical Debt Legacy Code People Organizations
Tuesday 9:00 - 17:00

Most organizations find it hard to prioritize and repay their technical debt. The main reason is the scale of modern systems with million lines of code and multiple development teams where no one has a holistic overview. So what if we could mine the collective intelligence of all contributing programmers and start to make decisions based on data from how the organization actually works with the code?

In this workshop you learn novel analysis techniques based on data from the most underused informational source that we have in our industry: our version-control system. You'll learn to:
  • Identify the code that's most expensive to maintain amongst millions lines of code.
  • Detect architectural decay in both layered and microservice systems.
  • Identify implicit dependencies across service boundaries.
  • Measure how multiple developers influence code quality and what you can do about it.
  • View your codebase from a social perspective and see how different organizational patterns influence the code you write.
  • Use behavioral code analysis to guide refactorings.
The practical exercises use CodeScene and Git for demonstrations, but this workshop isn't about tools. Rather, it's about pragmatic techniques and analyses that apply to systems of all scales. At the end you'll be able to base both technical and organizational decisions on data.


The workshop blends theory and practice in a hands-on style where we analyze real world codebases.


Participants need to bring their own laptop with a recent Java run-time (at least Java 8), a Git client (at least 2.15). Detailed preparations will be sent out in advance.
All participants are encouraged to take this opportunity to analyze their own codebase: just bring a local clone of your Git repositories.


Experienced developers, architects, and technical leads.

Programming languages

All techniques are language neutral and we show that by analyzing systems written in C, C#, Java, JavaScript, Scala, and many more.

Docker production: Swarm orchestration, security, and beyond

docker containers orchestration docker swarm swarm
Tuesday 9:00 - 17:00


Need to take your containers into production and operate Docker clusters like a pro? This workshop skips Docker basics and CI/CD topics. Rather, it focuses squarely on the tools and techniques of building and operating container clusters using Docker. Starting where previous Docker 101 workshops leave off, you'll dive into Swarm Mode clustering (Docker Services), rolling updates, monitoring, logging, troubleshooting, Swarm recovery, and Docker security features. This workshop covers the latest built-in Docker features and common third-party tools, and Bret will walk you through installing them on your own five-node cloud Swarm cluster in AWS.

What you'll learn

  • Walk through building a multi-node, secure Docker Swarm cluster in AWS.
  • Learn how to deploy and manage a multi-container, highly available microservice app inside that cluster.
  • Gain hands-on experience with daily and intermediate-level tasks a container cluster operator deals with.
  • Improve your security posture with optional Docker features.
  • Learn how Docker compose files can be used in production clusters.
  • Test rolling updates, failed update rollbacks, and implement healthchecks into your Dockerfiles.
  • Deploy centralized logging, monitoring, and data management options for Docker Swarm.

Prerequisite knowledge

  • A working knowledge of Docker (You are familiar with Docker images and containers, have used Dockerfile and docker-compose.yml in some fashion and understand the basic commands and purpose behind them.)
  • Shell and SSH basics for Linux. (We'll guide you through all commands.)
  • General understanding of microservice and distributed computing concepts. 

Materials needed in advance

  • A laptop with an SSH program installed


Docker Swarm

  • SSH into your five nodes and create a Swarm
  • Spin up a sample multicontainer microservice app
  • Use built-in commands to validate it’s working and logging; use troubleshooting techniques on the overlay networks and to jump into containers
  • Deploy redundant containers and test high availability
  • Use rolling updates to update apps without downtime, including rollback
  • Add healthchecks to Dockerfiles and Swarm Services
  • Deal with failed containers and failed cluster nodes

Common third-party tools for logging, monitoring, and troubleshooting

  • Set up and test ELK (Elasticsearch, Logstash, and Kibana)
  • Set up and test cAdvisor
  • Set up and test Prometheus

Key features of production systems

  • Docker security features - user namespace setup, storing secrets, network isolation
  • Failed Raft consensus scenarios and options to recover
  • Persistent data options for Docker clusters

Other things you’ll learn along the way

  • Troubleshooting and sysadmin tools you may have forgotten
  • New tools for the container admin
  • Staying up to date on Docker tool releases
  • Command aliases for quicker day-to-day container management
  • Shell scripts for common processes

Living Documentation, Step by Step

Living Documentation Agile Continuous Delivery Design Architecture Domain-Driven Design
Tuesday 9:00 - 17:00

If you prefer coding over writing documentation, then you’ll love Living Documentation! A Living Documentation changes at the same pace as software design and development, from establishment of business goals to capturing domain knowledge, creating architecture, designing software and coding. It builds on top of BDD and DDD, but it also has its own key principles and novels ways to dramatically improve your documentation at minimal extra cost by using well-crafted artifacts and judicious automation.

This workshop from Cyrille Martraire, the author of the book "Living Documentation" (Addison-Wesley Professional), will guide you on how to implement the approach in your projects. Even if you haven't read the book, this workshop is the right place to learn the main elements of a Living Documentation, step by step through a provided sample Java code base.

You will learn:

  • How most knowledge is already there somewhere in your artifacts, even in an implicit form
  • How just talking and working together may be enough documentation, and when it does not
  • How to augment the code to make it fully explicit for further use by people and tools
  • How to differentiate between stable and volatile knowledge, and how this informs the way to deal with it
  • How to create zero-maintainance Evergreen Documents
  • How to recognize Shameful Comments and improve your code from there
  • How a word cloud can tell if you're doing your domain model wrong
  • How to generate a Living Glossary straight out of the code
  • How Architectural Decisions Records can help make better decisions
  • How Design Patterns help document a design decision very efficiently
  • How to visualize a design structure by generating a Living Diagram from the code itself
  • How to use plenty of other techniques to improve your particular needs, and the main traps to avoid
  • How failing to do any of the above is in itself a valuable feedback
  • How to introduce the topic in your project and with your colleagues

What you will need

  • A working Java 8 environment with Maven for two attendees
  • The sample project (only using basic Java) will be available from github or from a USB key

Systems and Service Monitoring with Prometheus

prometheus metrics time series monitoring alerts alerting tsdb time series database query language
Tuesday 9:00 - 17:00

Prometheus is a popular open-source monitoring system and time series database. It features a multi-dimensional data model, a flexible query language, and integrates monitoring aspects all the way from client-side instrumentation to alerting.

In this introductory workshop, the co-creator of Prometheus will explain the architecture and concepts behind Prometheus. Participants will set up core Prometheus components (Prometheus server, Alertmanager, Grafana, Node Exporter, and more) and monitor an example service setup. Based on the example setup, we will explore the data model, query language, alerting, and dashboarding functionalities of Prometheus.

Delivering value early and often in practice

continuous delivery continuous deployment lean startup agile lean dark launch automated testing
Tuesday 9:00 - 17:00
Morgan Stanley

Our goal as software developers is to sustainably deliver value for our organizations. Conferences are a great opportunity to learn about the challenges other teams faced (challenges you might also be facing right now) and how those challenges can be solved. However, putting even the best of advice’s into practice is hard. This exciting day-long coding challenge will provide you with an opportunity to practice continuous delivery and related agile and lean principles. You and your team will compete with other teams in delivering the most value to your product. Along the way, our mentor will spend time with you and your team and give you advice personalized to your needs.

Please make sure to bring your laptop along, and that you have your development environment set up for at least one of the supported languages: Clojure, C#, Elixir, Go, Groovy, Haskell, Java, JavaScript, Perl, PHP, Python, Ruby, Scala, TypeScript. 

What you will learn:

  • How to use a continuous deployment pipeline to your advantage
  • How to cut your feedback loop down to hours or even minutes by deploying early and often
  • How to release new versions safely using feature toggles, dark launches, and shadow features in practice
  • How to make pragmatic decisions about when and how to test your software
  • How to split responsibilities within a team for maximum effectiveness 
  • How to sustainably react to a rapidly changing market and requirements
  • How to measure the success of your product and the effects of changes you deployed

Wednesday — Workshop Day 2

Scaling Organizations and Technology

scalability architecture devops organizational culture agile microservices
Wednesday 9:00 - 17:00


Successful Internet companies are built on a foundation of excellent culture, efficient organization, and solid technology. As a company needs to scale, all of these parts of the foundation need to grow and scale with it. This highly interactive workshop will provide a deep dive into modern best practices at innovative companies in Silicon Valley for scaling culture, organization, and technology.

Driven primarily by the presenter’s experience ranging from small Valley startups to Google and eBay, we will learn about:

  • Scalable Organizations
  • Scalable Development Process
  • Scalable Architecture
  • Scalable Culture

You will leave with concrete recommendations you can use to start implementing improvements in your own technology organization.

Intended audience is engineering leaders – CTO, VP Engineering, Director of Engineering


 Module 1: Scalable Organizations
  • Small Teams
  • Specialty Skills
  • Organizational Growth
  • Global and Remote Teams

Module 2: Scalable Development Process

  • What to Build and What NOT to Build
  • Prioritization
  • Test-Driven Development
  • Technical Debt
  • Continuous Delivery
  • Experimentation

Module 3: Scalable Architecture

  • Architecture Evolution
  • Monoliths and Microservices
  • Incremental Evolution
  • Service Patterns and Anti-Patterns

Module 4: Scalable Culture

  • Collaboration and Decisionmaking
  • Learning Culture and Blameless Post-mortems

Exploratory testing

Exploratory Testing
Wednesday 9:00 - 17:00

This one day tutorial is for both testers and developers wanting to perform Exploratory Testing as part of their approach to software testing. It teaches exploratory testing and how to apply it in a systematic and deliberate way. Learn how it use it to add depth to your testing by focusing on risk and understanding business value.


This class is experiential and contains practical exercises to help gain a basic exploratory testing skills.

The workshop will focus on the following aspects of Exploratory Testing:

  • Heuristics in Exploratory Testing

  • Models in Exploratory Testing

  • Exploratory Testing Strategy

  • Oracles & bug finding

  • Reporting to others

You will learn:

  • How to find bugs important bugs rapidly

  • How to find bugs without test cases

  • How to describe your testing to other people without using test case metrics

This tutorial requires a laptop, please bring one.

Presentation Aikido

Presentation skills Effective communication Visual design Confidence on stage Designing a presentation
Wednesday 9:00 - 17:00

The best, most effective presentations capture the audience quickly, hold their interest effortlessly, educate and entertain them in equal measure, and sometimes even inspire them. This full-day class explores simple and effective techniques for achieving those goals in any kind of technical presentation. 

The first half of the course focuses on preparation, content selection, delivery techniques, and handling questions (or the lack thereof). The second half of the course is an in-depth tutorial on improving the "look and feel" of your presentation materials--regardless of which presentation system you use. In particular, it demonstrates practical techniques for making your slides not suck. 

Who should attend? 
Anyone who needs to present technical information in front of colleagues, clients, or any other audience. 

Advanced Go

WITH Mark Bates
go golang
Wednesday 9:00 - 17:00

Advanced Go Workshop

You've been writing Go now for a few months and you want to take things to the next level, this Advanced Go workshop will get you there. In this workshop we will skip the language basics and dive into the topics that all Go developers need to know about when writing production level Go applications.

In this one day Advanced Go workshop we will cover the following topics:

  • Profiling and Benchmarking
  • Debugging Applications with Delve
  • Understanding context.Context
  • Using Reflection
  • Working with Databases
Along the way we'll learn lots of great little tips, tricks, and other hidden gems about Go.

Who is this workshop for?

  • You have a solid handle on the foundations of the Go langauge
  • You are proficient with using the command line tools for your chosen platform
  • You want to take your Go applications to the next level of performance and stability

Integrating Machine Learning into iOS Apps

machine learning iOS mobile bootstrapping
Wednesday 9:00 - 17:00

Apple released the Core ML framework in iOS11, making it simple to integrate machine learning models into your app. In this workshop, you will learn the lifecycle of training, deploying, and evaluating a machine learning model for making on device predictions. 

Compute power, large datasets, time, and deep expertise are only perceived barriers, and there are plenty of options for overcoming them! 
Using techniques such as transfer learning and taking inspiration from the plentiful resources from industry and academia, you can get started doing this now. Note: We will move beyond the common cat/dog classifier. 

As a reminder, predictions that have traditionally been made server side can now be made locally - offering unique advantages to the user, such as more data privacy and lower latency. Hardware improvements targeted for performing machine learning tasks (iPhone X’s A11 chip), industry standard models optimized for mobile (MobileNets), and many more recent developments signal that machine learning on mobile is part of the new path forward.

Target Audience:
• Experience building iOS apps in Swift
No previous machine learning experience necessary.

What we will cover:
• Brief overview of ML terminology, tasks, and common algorithms
• Typical end-to-end machine learning pipeline and where your iOS app fits into it
• Identifying areas of your app that could be helped with machine learning & clearly defining the problem(s) to be modeled
• Acquiring a suitable dataset
• Training a machine learning model using Tensor Flow. We'll also discuss other options such as Keras & Apple's TuriCreate 
open source training framework.
• Deploying the trained model to Core ML
• Integrating the Core ML model into your app to make predictions on device.
• Using Core ML in combination with Vision when performing computer vision tasks
• Evaluating the performance of your machine learning model

Building Great Teams: Culture and Core Protocols

leadership team teams culture high-performance positive bias autonomy freedom self-awareness connection interactive deep dive team building continuous teaming culture design agile extreme teaming refactoring
Wednesday 9:00 - 17:00
Morgan Stanley

Your team can be ten times better.

What does that mean? That means your professional team can accomplish 10x more work, do it with 10x more quality, 10x faster, or with 10x less resources. Your family can be 10x happier. Your school can be 10x more effective at helping people learn. Your community group can be 10x better at making life better for the people it serves. Even you yourself can be 10x more effective at getting what you want.

In other words, you can be great. Your team can be great.

Can you say these things about your teams?
  1. My projects are completed effortlessly on schedule and in budget every time.
  2. Every team I’ve ever been on has shared a vision.
  3. In meetings, we only ever do what will get results.
  4. No one blames “management," or anyone else, if they don’t get what they want.
  5. Everybody shares their best ideas right away.
  6. Ideas are immediately unanimously approved, improved, or rejected by the team.
  7. Action on approved ideas begins immediately.
  8. Conflict is always resolved swiftly and productively.
The Core Protocols are one way to make teams that have these characteristics.

Some of the things you’ll learn:
  • Results-oriented behaviors,
  • How to enter a state of shared vision with a team and stay there,
  • How to create trust on a team
  • How to stay rational and healthy
  • How to make team decisions effectively, and
  • How to move quickly and with high quality towards the team’s goals

Software Security Bootcamp: Architect's Edition

WITH Susan Sons
Security Refactor Code Triage
Wednesday 9:00 - 17:00

This day-long workshop will provide practical instruction in six essential activities that every security-conscious software engineer, software architect, and software project manager should know:

  • Code Triage, Code Rescue -- Take on a new, complex code base and rapidly find out where the biggest burning issues are, then make and execute a plan to untangle them.
  • Building and Maintaining Security Programs  -- Build security into the development process in a way that enables the production of great software, rather than inhibits it.
  • Security Culture 101 -- How to get an organization on board with secure software development practices, from the top down and bottom up.
  • Distribution Logistics -- How many vulnerable points exist in the chain between your developers and consumers, where malicious software could be injected into your trusted product?
  • Communicating Security -- How to get credit for your security accomplishments, and how to keep security expectations clear and reasonable within and outside the team.
  • Vulnerability Response Without Losing Your Mind -- Take a first responder's approach to fixing software vulnerabilities: get it done right and fast, without destroying your people or your code base along the way.

Preparing For the Workshop

  • Attendees should have experience developing software as part of a team, in any programming language.
  • Attendees should understand spoken and written English.
  • Bring a note-taking medium of choice.
  • You may also want a laptop or tablet to reference web resources during the workshop.

What to Expect

We won't get very deep into any particular code base: this is a completely programming language neutral presentation. We'll be focused on the process of producing secure and reliable code: what your team needs and what they need to do. The workshop is a combination of lecture, Q&A, and some planning and communication activities.

You'll  receive, included with the workshop, some print and digital reference material to help you put what you've learned into action.

Resilient Software Design in theory and practice

Resilience Distributed Systems Software Design Communication Paradigms Patterns Best Practices
Wednesday 9:00 - 17:00

To make the complex, distributed and highly interconnected system landscapes of today robust, responsive and highly available, we need to implement resilience into them at application level.

Many patterns for implementing resilience into an application exist. The daunting questions are how to slice (design) an application and which patterns to pick and combine in order to match your specific needs best.

This workshop will address those questions in three parts:
* In the first part you will learn about the challenges how to design applications in a resilient way, get an overview about the resilience pattern landscape, learn some of the most important patterns and when to apply them.
* In the second part you will have the opportunity to apply the just learned contents to a real-life case study and design and discuss your own resilient solution.
* In the last part we will complete the workshop with a peek in some complementing topics, like some advanced patterns, a resilient design cycle and how to introduce the topic into the software development process.

After this workshop, you will have a much deeper understanding how to design solutions that satisfy your specific robustness needs.

High-Performance Java Persistence

Wednesday 9:00 - 17:00

Based on my book, High-Performance Java Persistence, this workshop is meant to mind the gap between Java developers and Database programming. 

Most often, Java developers are very skilled when it comes to programming languages, design patterns, frameworks and everything that's related to their programming language of choice. However, the database is still uncharted territory, usually treated as a black box that we throw queries at and expect it to respond in no time. With this training, I want to get Java developers get to know more about RDBMS so that they can design their application data access layer accordingly.

In this workshop, we are going through various data access performance optimizations that are relevant for a great variety of Java Persistence frameworks.

Therefore, we are going to discuss:
  1. The best way to do database schema migrations. 
  2. Effective JDBC logging.
  3. How to assert the automatically generated SQL statements during testing.
  4. How to monitor database connection usage and provision connection pools.
  5. How to use JDBC batching and speed up write operations.
  6. How to use Statement caching efficiently to speed up read operations.
  7. Fetching best practices.
All in all, after attending this workshop, you'll know all sorts of tips that you can readily apply to your current enterprise project.

As prerequisites, you need a laptop, Java 1.8, Maven, PostgreSQL, and an Internet connection.

I've done this workshop both on-site and as a conference workshop (e.g. Voxxed Days Zurich), and I got very good feedback in return.

Designing Microservices

WITH Sam Newman
Wednesday 9:00 - 17:00

There is lots of theory out there about microservice architecture, but how often do you get to put that knowledge into practice? It's not feasible to re-architect your real system often, and certainly not in a single day, or is it? This brand new workshop from the author of Building Microservices gives you a safe space to explore ideas behind microservice architectures with peers from other organisations.

In this workshop, we'll share some framing for micro service architectures that explore the various forces that can drive the design and evolution of microservices, and then you'll participate in a series of interactive architectural kata exercises to put your new found knowledge to the test. Afterwards, you'll have a series of tools to take back to your own organisations to put into practice.

This workshop will cover

  • What makes a good microservice
  • How to use concepts from domain driven design to define service boundaries
  • Explore how to plan and manage a migration from a monolith to the microservice architecture
  • Understand how technical choices can impact the architecture itself
  • How to manage change and governance in a microservice environment


People who are in the process of moving to micro services, or are already on the path should get a lot out of the event. It's primarily aimed at people in technical leadership positions like tech leads and architects, but should be of use to any developer or operations person interested in how to move to microservices. Prior knowledge of service oriented architectures generally or microservices specifically is useful, but by no means essential.

Attendee Requirements

This is a participatory workshop. You won't get to just sit there and watch - the more you participate in the workshop, the more you'll get out!

Intro to the Menlo way

Joy Innovation Collaboration
Wednesday 9:00 - 17:00
Morgan Stanley

Experience Menlo’s joyful workplace and methodologies that support our collaborative and innovative business culture. This workshop includes stories recounting Menlo's earliest days and how Menlo has evolved. During the workshop you will learn how we use visual management, what our different team roles and responsibilities are, how we use pairing, and more. This one-day overview of Menlo’s internal process is a great introduction to Menlo's history and culture and how you can apply these things inside of your organization.

Tips from Psychology for Problem-solving

Thinking Problem-solving Working environment Decision-making Cognitive neuroscience
Wednesday 9:00 - 17:00

Unfortunately, those of us who struggle with complex problems for a living don't have time to keep up with the enormous amount of cognitive science research that could help us become better thinkers, better problem solvers, and better decision makers. Having devoted more than ten years to researching the fast-moving fields that almost daily reveal new information, Linda shares what she has uncovered—some of it surprising, some even counterintuitive. She summarizes the research and provides concrete tips for improving your individual, team, and organizational abilities. Most of us sit all day, believing that concentrating without moving, in a room with no natural light, drinking too much caffeine, after our usual night of less than six hours of sleep is the way to get work done. Linda offers ways to incorporate movement, take a break, change focus, brighten our environments, think better, and be happier. Learn the latest tips for boosting your problem-solving power.

Paradigms Lost, Paradigms Regained

programming paradigms OO functional programming programming languages
Wednesday 9:00 - 17:00

It is very easy to get stuck in one way of doing things. This is as true of programming as it is of life. Although a programming paradigm represents a set of stylistic choices, it is much more than this: a paradigm also represents a way of thinking. Having only way to think about problems is too limiting. A programming paradigm represents a set of patterns of problem framing and solving and contains the ingredients of software architecture. As Émile Auguste Chartier noted, there is nothing more dangerous than an idea when you have only one idea.

Perhaps even more problematic than being stuck with a narrow view of paradigms, is being stuck with a dysfunctional view of each paradigm. For instance, many developers working in languages and frameworks that support object orientation lack a strong idea of the principles of interaction, data abstraction and granularity that support an effective view of OO, and instead surround themselves with manager objects, singletons and DTOs.

During the day we will explore the character and style of different programming styles, patterns, paradigms, languages, etc., with examples and opportunity for discussion.

Getting Started with Serverless Architectures

javascript serverless aws lambda cloud
Wednesday 9:00 - 17:00

This is a practical workshop for developers and architects that want to take advantage of the latest trends in cloud computing: serverless apps and cloud functions. Through hands-on exercises and teamwork, you’ll learn about using AWS Lambda and API Gateway to create responsive event-driven micro-services, auto-scaling web APIs, and high-performance web sites. By the end of the workshop, you will create a useful real-world serverless application, exploring the typical architectural patterns.

Serverless platforms significantly reduce the cost of running high-performance web sites and API services in the cloud, but with a major impact on architecture, these services also require teams to re-think how to approach sessions, storage, authorization and testing.

The author of the workshop is Gojko Adzic, a key contributor to Claudia.js, a popular open-source deployment tool for AWS Lambda.

Learn how to:

  • Use AWS Lambda and API Gateway
  • Managing sessions and state with serverless architectures
  • Start converting monolithic applications to cloud functions
  • Use Amazon Serverless Application Model (SAM) and Claudia.js to deploy Lambda functions
  • Design scalable, high-performance web sites with single-page apps backed by cloud APIs
  • Identify how serverless architecture impacts testing, monitoring and deployments

Participant prerequisites

  • Working knowledge of JavaScript. The tools and techniques you’ll learn about will apply for any programming language, but the coding examples will be in JavaScript/Node.js to keep things simple and make it easy for everyone to follow regardless of their primary platform. You don’t need expert level knowledge of JavaScript, but you should be comfortable writing simple functions and flows. You don’t need prior experience with AWS services, but this would definitely be useful.
  • An Amazon Web Services account (free tier accounts are also OK, you can register at
  • Bring your own laptop, we'll be coding all the time

Software, Faster

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

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