Temporal modeling using EventStorming - mini workshop

Please join us at this hands-on mini workshop where we will practice EventStorming, a technique used for requirements gathering, modeling and creating a shared understanding amongst stakeholders. We will model a fictional application for managing sports races: marathon running, cycling, mountain biking etc. The session will last one and half hours and afterwards, our event sponsor, Maurer-Electronics, will provide pizza and drinks so we can continue socialising after the initial workshop.

EventStorming is a software modeling technique invented by Alberto Brandolini that facilitates collaboration between developers, domain experts, and stakeholders. Its primary purpose is to explore complex business domains and uncover the key events that drive the system's behavior. It’s particularly effective in the context of Domain-Driven Design (DDD). If you are interested in DDD please join the new DDD group in Split

### Key Concepts of EventStorming

1. Events as the Core Element:

• In EventStorming, the process revolves around identifying domain events, which are significant occurrences in the business domain (e.g., "Order Placed", "Payment Received").
• These events are usually represented by sticky notes on a physical or virtual board, and the team collaborates to map the sequence and context of these events.

2. Facilitated Workshop Format:

• EventStorming is often performed in a workshop setting where participants from various disciplines (developers, business stakeholders, product managers, etc.) contribute to the understanding of the system.
• It uses visual collaboration techniques to create a shared model of how a system should behave or how it currently functions.

3. Big Picture and Detailed Modeling:

• There are different levels of EventStorming: Big Picture, which captures high-level domain events, and Process Level, which dives deeper into specific processes, identifying commands, aggregates, policies, and read models that interact with those events.

### How EventStorming helps us capture user requirements and design solution

### 1. Understanding User Requirements through Collaboration

• Facilitating communication between stakeholders: Event Storming brings together domain experts, developers, and other stakeholders into the same room. The goal is to foster a shared understanding of the domain. Domain experts (business users, customers, etc.) provide insights into how the system should behave, which are essential for capturing requirements accurately.
• Capturing business processes in real time: Stakeholders and team members use sticky notes to map out events (e.g., things that happen in the domain, such as “Order Placed” or “Payment Received”) on a timeline. This visual approach encourages discussion and helps identify key processes, pain points, and gaps in the understanding of the system.

### 2. Defining Domain Events (Core to DDD)

• In Event Storming, domain events (events that happen in the business domain) are the central concept. This is aligned with DDD, where domain events help model the behavior and lifecycle of business entities.
• Each event corresponds to a specific change or action in the system, helping developers understand the key milestones in the business process and how users interact with the system.

### 3. Discovering Bounded Contexts

• As the domain events are laid out, patterns begin to emerge. This helps in identifying bounded contexts — a key concept in DDD that represents different parts of the system that have distinct models and rules.
• By grouping related events, the team can see how different areas of the system interact and where boundaries between subdomains or microservices should be drawn.

### How EventStorming Relates to Temporal Modeling and Event Sourcing

1. Temporal Modeling:

• Temporal modeling is a way of designing systems where time is an integral factor. It focuses on how the state of a system evolves over time.
• EventStorming naturally complements temporal modeling because the events identified during the process often represent specific changes in the system at particular points in time.

2. Event Sourcing:

• Event Sourcing is a design pattern where the state of an application is determined by a series of events, rather than storing just the current state.
• In an event-sourced system, every change to the application’s state is stored as an immutable event. The current state is reconstituted by replaying these events.
• EventStorming aligns well with Event Sourcing because the technique emphasizes identifying the key domain events that affect the system. By identifying and mapping these events, it provides the foundation for an event-sourced architecture.