Daniel Hinojosa

Event Driven Architecture

Monday, 9:00 AM EST

Event-driven architecture (EDA) is a design principle in which the flow of a system’s operations is driven by the occurrence of events instead of direct communication between services or components. There are many reasons why EDA is a standard architecture for many moderate to large companies. It offers a history of events with the ability to rewind the ability to perform real-time data processing in a scalable and fault-tolerant way. It provides real-time extract-transform-load (ETL) capabilities to have near-instantaneous processing. EDA can be used with microservice architectures as the communication channel or any other architecture.

In this workshop, we will discuss the prevalent principles regarding EDA, and you will gain hands-on experience performing and running standard techniques.

• Key Concepts of Event-Driven Architecture
• Event Sourcing
• Event Streaming
• Multi-tenant Event-Driven Systems
• Producers, Consumers
• Microservice Boundaries
• Stream vs. Table
• Event Notification
• Event Carried State Transfer
• Domain Events
• Tying EDA to Domain Driven Design
• Materialized Views
• Outbox Pattern
• CQRS (Command Query Responsibility Segregation)
• Saga Pattern (Choreography and Orchestrator)
• Avoiding Coupling
• Monitoring Systems
• Cloud-Based EDA

Architectural Patterns Focus: Security

Tuesday, 8:30 AM EST

In this session, we will discuss architectural concerns regarding security. How do microservices communicate with one another securely? What are some of the checklist items that you need?

• Valet Key
• mTLS and Sidecars
• Public Key Infrastructure (PKI)
• SASL
• Hashicorp Vault Keys
• SBOMs
• JSON Web Tokens

Architectural Patterns Focus: Fault Tolerance

Tuesday, 10:30 AM EST

This presentation will discuss the patterns required when things go wrong in architecture and how to stay resilient under pressure. These are battle-tested patterns that every architect should know.

• Circuit Breaker
• Throttling
• Retries
• Bulkhead
• Failover
• Fallback
• Timeout
• Leader Election
• Raft Protocol
• Competing Consumers
• Health Checks
• Replicator
• Idempotency
• Shadowing
• Graceful Degradation

Architectural Patterns Focus: Transactions

Tuesday, 1:00 PM EST

We take a look at another facet of architectural design, and that is how we develop and maintain transactions in architecture. Here we will discuss some common patterns for transactions

• TwoPhase Commit
• The Problem with 2PC
• Using EventDrivenArchitecture to manage transactions
• Transactional Outbox
• Compensating Transaction
• Optimistic vs Pessimistic Locking
• TCC (TryConfirm/Cancel)
• Saga Orchestrator
• Saga Choreography

Hexagonal Architecture

Tuesday, 3:00 PM EST

This workshop will explore the principles of the Ports and Adapters pattern (also called the Hexagonal Architecture) and demonstrate how to refactor legacy code or design new systems using this approach. You’ll learn how to organize your domain logic and move UI and infrastructure code into appropriate places within the architecture. The session will also cover practical refactoring techniques using IntelliJ and how to apply Domain Driven Design (DDD) principles to ensure your system is scalable, maintainable, and well-structured.

What You’ll Learn:

1. What is Hexagonal Architecture?
   Understand the fundamental principles of Hexagonal Architecture, which helps isolate the core business logic (the domain) from external systems like databases, message queues, or user interfaces. This architecture is designed to easily modify the external components without affecting the domain.

2. What are Ports and Adapters?
   Learn the key concepts of Ports and Adapters, the core elements of Hexagonal Architecture. Ports define the interface through which the domain interacts with the outside world, while Adapters implement these interfaces and communicate with external systems.

3. Moving Domain Code to Its Appropriate Location:
   Refactor your domain code to ensure it is correctly placed in the core domain layer. You will learn how to separate domain logic from external dependencies, ensuring that business rules are isolated and unaffected by user interface or infrastructure changes.

4. Moving UI Code to Its Appropriate Location:
   Discover how to refactor UI code by decoupling it from the domain logic and placing it in the appropriate layers. You’ll learn how to use the Ports and Adapters pattern to allow the user interface to communicate with the domain without violating architectural boundaries.

5. Using Refactoring Tools in IntelliJ:
   Learn how to use IntelliJ’s powerful refactoring tools to streamline code movement. Techniques such as Extract Method, Move Method, Extract Delegate, and Extract Interface will be applied to refactor your codebase.

6. Applying DDD Software Principles:
   We’ll cover essential Domain-Driven Design principles, such as Value Objects, Entities, Aggregates, and Domain Events.

7. Refactoring Techniques:
   Learn various refactoring strategies to improve code structure, Extract Method, Move Method, Extract Delegate, Extract Interface, and Sprout Method and Class

8. Verifying Code with Arch Unit:
   Ensure consistency and package rules using Arch Unit, a tool for verifying the architecture of your codebase. You will learn how to write tests confirming your project adheres to the desired architectural guidelines, including separating layers and boundaries.

Who Should Attend:

This workshop is perfect for developers who want to improve their understanding of Ports and Adapters Architecture, apply effective refactoring techniques, and leverage DDD principles for designing scalable and maintainable systems.

Hexagonal Architecture

Tuesday, 5:00 PM EST

This workshop will explore the principles of the Ports and Adapters pattern (also called the Hexagonal Architecture) and demonstrate how to refactor legacy code or design new systems using this approach. You’ll learn how to organize your domain logic and move UI and infrastructure code into appropriate places within the architecture. The session will also cover practical refactoring techniques using IntelliJ and how to apply Domain Driven Design (DDD) principles to ensure your system is scalable, maintainable, and well-structured.

What You’ll Learn:

1. What is Hexagonal Architecture?
   Understand the fundamental principles of Hexagonal Architecture, which helps isolate the core business logic (the domain) from external systems like databases, message queues, or user interfaces. This architecture is designed to easily modify the external components without affecting the domain.

2. What are Ports and Adapters?
   Learn the key concepts of Ports and Adapters, the core elements of Hexagonal Architecture. Ports define the interface through which the domain interacts with the outside world, while Adapters implement these interfaces and communicate with external systems.

3. Moving Domain Code to Its Appropriate Location:
   Refactor your domain code to ensure it is correctly placed in the core domain layer. You will learn how to separate domain logic from external dependencies, ensuring that business rules are isolated and unaffected by user interface or infrastructure changes.

4. Moving UI Code to Its Appropriate Location:
   Discover how to refactor UI code by decoupling it from the domain logic and placing it in the appropriate layers. You’ll learn how to use the Ports and Adapters pattern to allow the user interface to communicate with the domain without violating architectural boundaries.

5. Using Refactoring Tools in IntelliJ:
   Learn how to use IntelliJ’s powerful refactoring tools to streamline code movement. Techniques such as Extract Method, Move Method, Extract Delegate, and Extract Interface will be applied to refactor your codebase.

6. Applying DDD Software Principles:
   We’ll cover essential Domain-Driven Design principles, such as Value Objects, Entities, Aggregates, and Domain Events.

7. Refactoring Techniques:
   Learn various refactoring strategies to improve code structure, Extract Method, Move Method, Extract Delegate, Extract Interface, and Sprout Method and Class

8. Verifying Code with Arch Unit:
   Ensure consistency and package rules using Arch Unit, a tool for verifying the architecture of your codebase. You will learn how to write tests confirming your project adheres to the desired architectural guidelines, including separating layers and boundaries.

Who Should Attend:

This workshop is perfect for developers who want to improve their understanding of Ports and Adapters Architecture, apply effective refactoring techniques, and leverage DDD principles for designing scalable and maintainable systems.

Architectural Patterns Focus: EventDriven Architecture & Messaging

Wednesday, 9:00 AM EST

Join us for an indepth exploration of cuttingedge messaging styles in your large domain.

Here, we will discuss the messaging styles you can use in your business.

• Event Sourcing
• EventDriven Architecture
• Claim Check
• Event Notification
• Event Carried State Transfer
• Domain Events

Architectural Patterns Focus: Data

Wednesday, 11:00 AM EST

This session will focus on data governance and making data available within your enterprise. Who owns the data, how do we obtain the data, and what does governance look like?

• CQRS
• Materialized Views
• Warehousing vs Data Mesh
• OLAP vs OLTP
• Pinot, Kafka, and Spark
• Business Intelligence
• Making Data Available for ML/AI

Apache Flink: Unlocking the Power of Real-Time Data Processing

Wednesday, 1:30 PM EST

In today’s data-driven world, the ability to process and analyze data in real time is no longer a luxury—it’s a necessity. Apache Flink, a powerful stream processing framework, has emerged as a game-changer for handling high-throughput, low-latency data applications.

In this session, you’ll gain a clear understanding of what Apache Flink is, how it works, and why it’s become a cornerstone for modern data infrastructure. We’ll explore key features such as its robust stream and batch processing capabilities, event-time handling, stateful computations, and fault tolerance. You’ll also discover how Flink integrates seamlessly with popular systems like Kafka, Kubernetes, and major cloud platforms.

Whether you’re working with real-time analytics, event-driven applications, or machine learning pipelines, Apache Flink provides the scalability and flexibility needed to turn massive streams of data into actionable insights. Join us to see why Flink is critical to modern data ecosystems and learn how to start leveraging its power in your projects.

From DDD to Delivery

Thursday, 9:00 AM EST

Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?

In this workshop, we will break it down into pairs of topics.

• Subdomains to Architecture Boundaries
• Where do Microservices fit in?
• Where does DataMesh fit in?
• How do subdomains and bounded contexts fit in?
• What is shared kernel technology-wise? Is it a library or a service?
• Where do we put human beings in all this?
• What can we afford to do?
• What kind of technology shopping list are we looking at?

In this workshop, we will perform the following activities

• Event Storming but with a Technology Focus
• Context Mapping but with a Technology Focus
• Decide how to implement some common patterns with a Technology Focus

From DDD to Delivery

Thursday, 11:00 AM EST

Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?

In this workshop, we will break it down into pairs of topics.

• Subdomains to Architecture Boundaries
• Where do Microservices fit in?
• Where does DataMesh fit in?
• How do subdomains and bounded contexts fit in?
• What is shared kernel technology-wise? Is it a library or a service?
• Where do we put human beings in all this?
• What can we afford to do?
• What kind of technology shopping list are we looking at?

In this workshop, we will perform the following activities

• Event Storming but with a Technology Focus
• Context Mapping but with a Technology Focus
• Decide how to implement some common patterns with a Technology Focus