Daniel Hinojosa

Event Driven Architecture

9:00 AM MDT

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

Stay Ahead with Java’s Latest Features in JDK 23!

8:30 AM MDT

Java’s evolution is remarkable, and the leap from JDK 17 to JDK 23 brings a wealth of powerful features to elevate your projects. Join us for an exciting session to explore select JEPs (Java Enhancement Proposals) introduced up to JDK 23, diving into their use cases and practical benefits for your work or open-source initiatives.

What You’ll Learn:
How to enable and utilize advanced Java features introduced in JDK 23.
Real-world demonstrations of cutting-edge updates, including:

• Stream Gatherers: Handle complex data streams with ease.
• Statements Before super(): Test invariants without constructing objects.
• Unnamed Variables and Parameters: Enhance code readability and maintainability.
• Launch Multi-File Source-Code Programs: Rapidly prototype with multiple source files.
• Implicitly Declared Classes & Enhanced Main Methods: Streamline application development.
• Updates on switch Expressions: We will discuss pattern matching as well as dealing with primitives
• Structured Concurrency and Scoped Values. Additional concurrent APIs that are used with Virtual Threads.

Why Attend?
Learn how to advocate for and implement your organization's latest Java tools and practices. Gain the knowledge you need to sell the value of next-generation Java and stay at the forefront of software development.

Architectural Patterns Focus: EventDriven Architecture & Messaging

10:30 AM MDT

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: Security

1:00 PM MDT

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: Transactions

3:00 PM MDT

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

Architectural Patterns Focus: Data

5:00 PM MDT

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

Gitops: From Commit to Deploy

9:00 AM MDT

Join us for a hands-on workshop, GitOps: From Commit to Deploy, where you’ll explore the entire lifecycle of modern application deployment using GitOps principles.

We’ll begin by committing an application to GitHub and watching as your code is automatically built through Continuous Integration (CI) and undergoes rigorous unit and integration tests. Once your application passes these tests, we’ll build container images that encapsulate your work, making it portable, secure, and deployment-ready. Next, we’ll push these images to a container registry preparing for deployment

Next, you will learn how to sync your application in a staging Kubernetes cluster using ArgoCD (CD), a powerful tool that automates and streamlines the deployment process. Finally, we’ll demonstrate a canary deployment in a production environment with ArgoCD, allowing for safe, gradual rollouts that minimize risk.

By the end of this workshop, you’ll have practical experience with the tools and techniques that perform GitOps deployments, so you can take this information and set up your deployments at work.

• Creating Your Application
• Running Locally
• Proper Commits
• Security Scans
• Safe Image Creation
• Image Publishing
• ArgoCD and Syncing
• Canary Deployments

Gitops: From Commit to Deploy

11:00 AM MDT

Join us for a hands-on workshop, GitOps: From Commit to Deploy, where you’ll explore the entire lifecycle of modern application deployment using GitOps principles.

We’ll begin by committing an application to GitHub and watching as your code is automatically built through Continuous Integration (CI) and undergoes rigorous unit and integration tests. Once your application passes these tests, we’ll build container images that encapsulate your work, making it portable, secure, and deployment-ready. Next, we’ll push these images to a container registry preparing for deployment

Next, you will learn how to sync your application in a staging Kubernetes cluster using ArgoCD (CD), a powerful tool that automates and streamlines the deployment process. Finally, we’ll demonstrate a canary deployment in a production environment with ArgoCD, allowing for safe, gradual rollouts that minimize risk.

By the end of this workshop, you’ll have practical experience with the tools and techniques that perform GitOps deployments, so you can take this information and set up your deployments at work.

• Creating Your Application
• Running Locally
• Proper Commits
• Security Scans
• Safe Image Creation
• Image Publishing
• ArgoCD and Syncing
• Canary Deployments

Refactoring to Hexagonal Architecture

Putting Code in the Correct Place

1:30 PM MDT

In this workshop, we will explore the principles of Hexagonal Architecture (also known as the Ports and Adapters pattern) 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 DomainDriven Design (DDD) principles to ensure your system is scalable, maintainable, and wellstructured.

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 remain 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 the process of moving code around. 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 DomainDriven Design principles, such as:
   • Value Objects: Immutable objects that hold attributes with no identity.
   • Entities: Objects with an identity that persists through different states.
   • Aggregates: Clusters of domain objects treated as a single unit.
   • Domain Events: Events that signify something significant has occurred within the domain.
7. Refactoring Techniques:
   Learn various refactoring strategies to improve code structure:
   • Extract Method: Break down complex methods into smaller, more manageable ones.
   • Move Method: Move a method to a more appropriate class or layer.
   • Extract Delegate: Use delegation to delegate method calls to the appropriate class.
   • Extract Interface: Create interfaces to separate concerns and enable easier testing and maintenance.
   • Sprout Method and Class: Create new methods or classes to enhance readability, flexibility, and adherence to the Single Responsibility Principle.
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 Hexagonal Architecture, apply effective refactoring techniques, and leverage DDD principles for designing scalable and maintainable systems.

Refactoring to Hexagonal Architecture

Putting Code in the Correct Place

3:15 PM MDT

In this workshop, we will explore the principles of Hexagonal Architecture (also known as the Ports and Adapters pattern) 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 DomainDriven Design (DDD) principles to ensure your system is scalable, maintainable, and wellstructured.

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 remain 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 the process of moving code around. 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 DomainDriven Design principles, such as:
   • Value Objects: Immutable objects that hold attributes with no identity.
   • Entities: Objects with an identity that persists through different states.
   • Aggregates: Clusters of domain objects treated as a single unit.
   • Domain Events: Events that signify something significant has occurred within the domain.
7. Refactoring Techniques:
   Learn various refactoring strategies to improve code structure:
   • Extract Method: Break down complex methods into smaller, more manageable ones.
   • Move Method: Move a method to a more appropriate class or layer.
   • Extract Delegate: Use delegation to delegate method calls to the appropriate class.
   • Extract Interface: Create interfaces to separate concerns and enable easier testing and maintenance.
   • Sprout Method and Class: Create new methods or classes to enhance readability, flexibility, and adherence to the Single Responsibility Principle.
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 Hexagonal Architecture, apply effective refactoring techniques, and leverage DDD principles for designing scalable and maintainable systems.

Introduction to a new space: MLOps

5:00 PM MDT

Join us for a session on MLOps, where we delve into the transformative practices and tools that bridge the gap between machine learning development and production deployment. Discover how MLOps enhances collaboration, reproducibility, and scalability in machine learning projects, ensuring seamless transitions from data engineering to model monitoring. Learn about the latest technologies, including Docker, Kubernetes, and MLflow, and explore realworld case studies highlighting best practices and common challenges. Whether you’re a data scientist, engineer, or manager, this session will equip you with the knowledge to streamline your ML workflows and drive impactful business outcomes.

This presentation will assume that the attendees have little to no knowledge of creating and operationalizing ML Models.

In this presentation, we will perform a rigorous list of what is required to be successful in the MLOps space.

• Model Development
• Model Packaging
• Model Deployment
• Model Cataloging
• Model Monitoring
• Model Maintainance

Then, we will discuss the technologies that we can use to piece these technologies together:

Some of the technologies we will discover include:

• Airflow, Kubeflow, MLFlow
• Prometheus & Grafana
• TensorFlow, XGBoost, Dask, and More
• Serving Models
• Kafka
• Hyperparameter Tuning

From DDD to Delivery

8:30 AM MDT

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

10:30 AM MDT

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