Daniel Hinojosa

Domain Driven Design Deep Dive

9:00 AM MDT

Domain Driven Design has been one of the major cornerstones in large system design for many years. It has recently been in the zeitgeist as of late, especially when it comes to the terms bounded context and microservices. This full-day class introduces you to Domain Driven Design, and why it is important. We will cover the design and pattern, discuss subdomains, context mapping, tools, and management

Our workshop will not only introduce you to the terms, but we will cover planning, and go through challenges on design so we can discuss the tradeoffs that come with the design. We will also cover some of the more modern patterns that came out of DDD like CQRS, Data Mesh, Rest, and more.

Architectural Patterns Focus: Security

8:30 AM 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: 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

Java Design Patterns To Go

1:00 PM MDT

Since 1994, the original Gang of Four Design Patterns book, “Design Patterns: Elements of Reusable Object-Oriented Software” has helped developers recognize common patterns in development. The book was originally written in C++, but there have been books that translate the original design patterns into their preferred language. One feature of “The Gang of Four Design Patterns” that has particularly stuck with me has been testability for the most part. With the exception of singleton, all patterns are unit-testable. Design Patterns are also our common developer language. When a developer says, “Let's use the Decorator Pattern,” we know what is meant.

What's new, though, is functional programming, so we will also discuss how these patterns change in our new modern functional programming world. For example, functional currying in place of the builder pattern, using an enum for a singleton, and reconstructing the state pattern using sealed interfaces. We will cover so much more, and I think you will be excited about this topic and putting it into practice on your codebase.

Java Design Patterns To Go

3:00 PM MDT

Since 1994, the original Gang of Four Design Patterns book, “Design Patterns: Elements of Reusable Object-Oriented Software” has helped developers recognize common patterns in development. The book was originally written in C++, but there have been books that translate the original design patterns into their preferred language. One feature of “The Gang of Four Design Patterns” that has particularly stuck with me has been testability for the most part. With the exception of singleton, all patterns are unit-testable. Design Patterns are also our common developer language. When a developer says, “Let's use the Decorator Pattern,” we know what is meant.

What's new, though, is functional programming, so we will also discuss how these patterns change in our new modern functional programming world. For example, functional currying in place of the builder pattern, using an enum for a singleton, and reconstructing the state pattern using sealed interfaces. We will cover so much more, and I think you will be excited about this topic and putting it into practice on your codebase.

JDK Features To Get Excited About

5:00 PM MDT

Java advances quickly. It is incredible how much incremental change accumulates over time. JDK 17 is now three years old, and we are at JDK 22 as of 2025. In this session, I will take some select JEPs (Java Enhancement Process) and demonstrate what they are and their use case. Then you can be ahead of the curve, and give you all the information you need to sell and demand the next generation Java for your work or opensource initiative.

• How do you turn on these advanced features?
• Stream Gatherers
• Statements before super()
• Unnamed Variables and Parameters
• Launch Multi-File Source-Code Programs
• Implicit Declared Classes and Enhanced Main Methods
• Updates on switch expressions
• Stable Values

IntelliJ Jedi Tricks

8:00 PM MDT

This presentation is the Dagobah of efficient editing and flow. Come only what you take with you.

Most efficient you will be, when keyboard tricks learned. You'll see. Hmmmm. You must unlearn what you have learned. A Jedi's power comes from knowledge of the tools used. Luminous beings are we… not crude typists. Mouse is your weakness. Learn to use more of the keyboard, you will.

Learn:

1. Window Management
2. Programming Flow
3. Templating
4. Version Control Management
5. Testing
6. Tooling
7. Multicursors
8. Emmet
9. Debugging

Kafka Fundamentals

9:00 AM MDT

Kafka is a “must know.” It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs. As such, Kafka has become an essential product in the microservice and big data world.

This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.

Kafka Fundamentals

11:00 AM MDT

Kafka is a “must know.” It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs. As such, Kafka has become an essential product in the microservice and big data world.

This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.

Kafka Connect: Harnessing Data Stores

1:30 PM MDT

In this presentation, we will discuss Kafka Connect. Kafka Connect is an opensource project from Confluent. Kafka Connect provides us a way to move data from a data store as a source and stream or batch that information into Kafka. Kafka Connect also gives us a way to take information from Kafka and send that to another data store, a Sink. Every source and sink can be connected to and from various databases and message queues.

What this presentation will entail:

• A brief overview and review of Kafka
• The Architecture of Kafka Connect
• Where to find connectors
• Standalone vs Distributed
• Connecting a Source
• Creating Single Message Transforms
• Connecting a Sink

At the end of this presentation, we will have a live demonstration of watching a data pipeline using data stores.

Kafka Streams and KSQLDB

3:15 PM MDT

Kafka is more than just a messaging queue with storage. It goes beyond that and with technology from Confluent open source it has become a full-fledged data ETL and data streaming ecosystem.

When we utter the words, Kafka, it is no longer just one component but can be an entire data pipeline ecosystem to transform and enrich data from source to sink. It offers different ways to handle that data as well. In this presentation, we define:

• Streaming Concepts
• Using functional programming to manipulate your data
• Co-partitioning
• Aggregations

We then discuss KSQLDB. A SQL layer built upon Kafka Streams that provides a simple query language to perform streaming operations

• Persistent Queries
• Non-Persistent Queries
• Fault-Tolerance

From DDD to Delivery

5:00 PM 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 presentation, we will break it down into pairs of topics.

• Subdomains to Architecture Boundaries
• Bounded Contexts
• Context Mapping
• Value Objects, Entities, and Aggregates
• Where do Microservices fit in?
• How do subdomains and bounded contexts fit in?
• Where do we put human beings in all this?
• What is Event Storming

The Java Sessions: Virtual Threads and Structured Concurrency

8:30 AM MDT

There is a new way of Threading, which means it is time to prepare. Project Loom has introduced Java Virtual Threads, which is now available in Java 21. Virtual Threads are small Threads meant to perform quick operations with the need to procure long-running OS threads, which can prove expensive. In this presentation, we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, and what does it mean for third-party libraries.

• What is a Virtual Thread
• Creating and Using a Virtual Thread
• What will Loom's Virtual Threads do to Future and Reactive
• What is a Continuation?
• What is Structured Concurrency?
• What are Scoped Values

The Java Sessions: Threading and Synchronizers

10:30 AM MDT

Threading has always been tough. Even with new frameworks that can make it easy, sometimes we don't have them at our disposal. This full-day session focuses on threading and the various synchronizers in Java. We will have material you can use as a reference and challenges that will help you remember some pitfalls to avoid.

• Concurrency vs. Parallelism
• Happens Before Guarantee
• volatile
• Starvation, Livelock, Deadlocks, and Race Conditions
• Using Composition over Inheritance
• Locks and choosing the right locks
• Wait, Notify, and Notify All
• Synchronizers
• CyclicBarrier
• Phaser
• CountdownLatch
• Semaphores