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


If you'd like to attend any of these workshops, please note that you will need to purchase a separate ticket. Craft Conference tickets by themselves do NOT include the workshops.

If you can not find a ticket for any of the listed workshops, check back on the website later, we are updating the website and adding the tickets every few days.

Paradigms Lost, Paradigms Regained: Programming with Objects and Functions and More

paradigms, functional programming, object orientation, procedural programming, concurrency
May 27, 28 (14:30-18:00 CEST)

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 programming 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 have 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.

This session explores the strengths and weaknesses of different programming styles, patterns and paradigms across different programming languages, past and present.

Surviving Legacy Code

evolutionary design, refactoring, design, tdd, xp, continuous improvement, legacy code, testing
May 27, 28 (14:30-18:00 CEST)

We all have legacy code, meaning profitable code that we’re afraid to change. It doesn’t matter who wrote it, in which language, nor when. It matters that we feel the fear now and need to deal with it. Rewrite or refactor? How do we write useful tests? There’s so much to change; how do we get started? When do we stop? Will it ever get any easier? In the typical programmer’s day job, there’s no time to learn how to do this. We’re already behind schedule and the cost of fixing the legacy code is crushing us. We need a way to learn how to do this safely, correctly, and eventually, even quickly. That’s what Surviving Legacy Code is about.

Getting API Design right - Hands on

API design Functional design Anti-patterns API experience
May 31, June 1 (14:30-18:00 CEST)

Everyone is talking about APIs, be it simple services or complete ecosystems that you want to expose via API. With all the tooling available, that is quite easy, is the first thought. But it is not.

The challenge of an API is not its implementation, but its design: What needs to go into the API, what do I leave out? How do I present it in a way that users find it good? What else do I need to take into account if I want my API to be a success?

In this workshop we will take a practical approach to the design of APIs using several case studies. We will intersperse short theory blocks that we try to put into practice, turning widespread bad practices into good ones.

This way, we will learn good functional API design step by step - aha-experiences included.

Shortcut to Tech Leadership Workshop (4 hours online)

techlead architect leader
May 28 (14:30-18:30 CEST)

This is an online guided workshop that accelerates your tech leadership journey. This workshop will boost your skills, accelerate your career development, offer you tools and tricks to lead technical teams and guide you through the journey from maker to multiplier.

At the end of this workshop, you will be able to:

- Understand what technical leadership is, and why it’s important for successful teams

- Explain what effective technical leadership looks like

- Describe your Technical Vision in depth

- Outline 8 foundation principles of effective technical leadership

- Identify the different behaviours of Makers and Multipliers

- Use 5 foundation skills that Multipliers draw upon a daily basis

High-Performance Team Building™: Core Protocols for EI and Psychological Safety

core protocols team teams high-performance psychological safety safety ei tei emotional intelligence team emotional intelligence team building fun activities
May 31, June 1 (14:30-18:00 CEST)

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 fewer 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. Greatness Can you say these things about your teams?

  1. My projects are completed effortlessly on schedule and within 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. - Everybody shares their best ideas right away.
  5. Ideas are immediately unanimously approved, improved, or rejected by the team.
  6. Action on approved ideas begins immediately.
  7. 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
  • How to move quickly and with high quality towards the team’s goals

Building Incremental (Agile, Evolutionary) Architecture

agile software architecture ddd event storming domain-driven design
May 31, June 1 (17:00-20:00 CEST)

A big-up-font design is a sure way to build the wrong thing. We learn as we work, and the things we learn impact our architecture. In a modern, agile, world we design systems incrementally as the system evolves rather than in one giant up-front phase. We design incrementally as we build. Nonetheless, our designs must still be coherent and able to easily stand up to the stress of changing requirements. This philosophy is particularly true in the microservice and Agile worlds. This practical workshop shows you how to design a system that can evolve incrementally. You'll learn: • the simplicity principle—build the simplest thing that does the job. • several architectural patterns appropriate for incremental development • how to create strictly-isolated highly decoupled subsystems • domain-focused architectures (including DDD) • how to use the domain to get system coherence over time • how to identify key abstractions, bounded contexts, entities, aggregates. • how to use events and messaging instead of declarative interfaces and APIs • event storming as both an analysis and design tool In all, you'll learn how to build a coherent and highly maintainable system and architecture that can easily accommodate changing requirements and grow incrementally as the system evolves.

Mob Programming Workshop

Mob Programming
May 31, June 1 (14:30-18:00 CEST)

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 a day of learning and doing Mob Programming. We cover the mechanics of how to work together as a Mob as well as the techniques that make this form of development so effective. We’ll learn how a Mob performs 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 it's significant benefits for your teams.

Hands-on threat modeling for agile development

June 15, 17 (14:30-18:00 CEST)

We created a 1-day online threat modeling course specifically for agile development to improve reliability and security of delivered software. You will learn an iterative and incremental threat modeling method that is integrated in the development and deployment pipeline You will be challenged to perform practical threat modeling covering the different stages of threat modeling. Exercises are built upon a fictional Acme Hotel Booking (AHB) system, where we migrate a legacy client-server system towards a cloud based, micro service stack using AWS services:

  • Sprint 1: Modeling a hotel booking web and mobile application, sharing a REST backend
  • Sprint 2: Threat identification as part of migrating the booking system application to AWS
  • Sprint 3: AWS threat mitigations for the booking system build on microservices
  • Sprint 4: Building an attack library for CI/CD pipelines This course is for you if you are a product manager, software developer, architects, DevOps engineer or application security professional.

Refactoring to Cleaner Code

C# C Sharp Refactoring Legacy Code Micro Commits Emergent Design Open Closed Principle Software development code craft Mob programming
May 31, June 1 (14:30-18:00 CEST)

Often we find ourselves working with code where the functions are too long, the coding standards are inconsistent, comments are missing or out of date, and the tests are incomplete. Let’s learn how to handle that situation better.

In this hands-on class we’ll take a long, confusing method and show you multiple techniques to refactor it to clean, concise, understandable, and testable code. Commonly this is done by carefully architecting a better solution and then undertaking a rewrite of the code. That’s not what we’re going to do here. Instead, we’ll discover a better solution through a series of small, safe steps that allow you to improve the code even when you only have a little time to spend on it.
Learn to:

  • Provable refactorings
  • Extract Paragraphs
  • Naming as a process
  • Git Commit Notation
  • Extract to Classes
  • Conform to interfaces
  • Extract Interface
  • Many of 1
  • Strategy pattern
  • Factory pattern