Daniel Hinojosa

Thinking Functionally in Java and the JVM

9:00 AM MDT

Java has quietly absorbed functional ideas over the last decade. Lambdas, streams, records, sealed types. It has been an amazing journey, but most teams still write code as if none of that really changed anything. This workshop asks a simple question: what if we actually took those features seriously?

In Thinking Functionally in Java, we explore how far disciplined functional design can take us using plain Java with no rewrites, no new language mandates, and no academic detours. Along the way, we address reproducible development environments with Nix, replace exception-driven control flow with explicit error modeling, and uncover why concepts like flatMap, algebraic data types, and composability matter even if you never say the word “monad” out loud.

• Reproducible Java Environments with Nix – Defining a deterministic Java toolchain so “works on my machine” stops being a variable.
• Functional Java: What We Actually Have – Referential transparency, immutability, and total functions using modern Java features.
• Type-Driven Design: Separating data from behavior (Show, Eq) and understanding the limits of Java’s type system.
• Composition with flatMap: Sequencing computations across Optional, streams, and error-handling types.
• Understanding Monads: Context, short-circuiting, composition, and trade-offs without mysticism.
• Algebraic Data Types in Java: Modeling closed domains with sealed types instead of flags and conditionals.
• Errors as Data: Replacing exception-driven control flow with explicit result types (Either, Try).
• Putting It Together: Designing a small, readable service that isolates side effects and composes cleanly.
• Breaking the Java Wall: A look at higher-kinded types, effects, and what Java still can’t express in languages other than Java

What's New In Java Half-Day Part 1

An always changing look into what is new in the Java ecosystem

8:30 AM MDT

Java has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.

Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.

• sealed classes
• record
• Pattern Matching
• Text Blocks
• switch expressions
• Stream Gatherers
• Flexible Constructor Bodies

What's New In Java Half-Day Part 1

An always changing look into what is new in the Java ecosystem

10:30 AM MDT

Java has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.

Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.

• sealed classes
• record
• Pattern Matching
• Text Blocks
• switch expressions
• Stream Gatherers
• Flexible Constructor Bodies

What's New In Java Half-Day Part 2

1:00 PM MDT

Java has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.

Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.

• Implicitly Declared Classes & Enhanced Main Methods
• Simple Web Server
• HTTPClient
• Multi-File Source Launching
• JShell
• Stable Values

What's New In Java Half-Day Part 2

3:00 PM MDT

Java has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.

Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.

• Implicitly Declared Classes & Enhanced Main Methods
• Simple Web Server
• HTTPClient
• Multi-File Source Launching
• JShell
• Stable Values

Java's Asynchronous Ecosystem

Too Many Tools, One JVM

5:00 PM MDT

Java has accumulated a diverse toolbox for concurrency and asynchrony over the decades, ranging from classic threads to parallel streams, from Future to CompletableFuture, and from reactive libraries to the latest innovations, including virtual threads, structured concurrency, and the Vector API. But with so many options, the question is: which ones should we use today, which still matter, and which belong in the history books?

In this talk, we’ll explore the entire spectrum:

• Classic Threads – the original concurrency primitive.
• Parallel Streams – data parallelism for the collections era.
• Futures & CompletableFuture – async results with callbacks and chaining.
• Reactive Programming – backpressure, publishers, and the rise of frameworks like Reactor and RxJava.
• Virtual Threads – Lightweight Concurrency Made Mainstream.
• Structured Concurrency – Taming async chaos with lifetimes and scopes.
• Vector API – data-level parallelism on modern CPUs.

We’ll also tackle the hard questions:

• Do virtual threads really kill the need for reactive programming?
• What does it mean by “hidden stack traces,” and how do they impact debugging and profiling?
• Where should you invest today, and what patterns should you abandon permanently?

Java Testing Lab: Test Driven Development (with Ai)

9:00 AM MDT

In this half-day workshop, we’ll practice Test-Driven Development (TDD) by solving a real problem step by step. You’ll learn how to think in tests, write clean code through refactoring, and use your IDE and AI tools effectively. We’ll also explore how modern Java features (like lambdas and streams) enhance testability, and discuss what’s worth testing — and what’s not.

• Process of Testing
• Refactoring and Clean Code
• Benefits
• Setting a Project
• Using IDEs to your absolute advantage
• What role do new Java 8 Lambdas play in testing
• What to test and what not to test
• Integration with Ai
• Property-Based Testing

Java Testing Lab: Test Driven Development (with Ai)

11:00 AM MDT

In this half-day workshop, we’ll practice Test-Driven Development (TDD) by solving a real problem step by step. You’ll learn how to think in tests, write clean code through refactoring, and use your IDE and AI tools effectively. We’ll also explore how modern Java features (like lambdas and streams) enhance testability, and discuss what’s worth testing — and what’s not.

• Process of Testing
• Refactoring and Clean Code
• Benefits
• Setting a Project
• Using IDEs to your absolute advantage
• What role do new Java 8 Lambdas play in testing
• What to test and what not to test
• Integration with Ai
• Property-Based Testing

Monitoring Systems with Prometheus and Grafana

Scrape it! Measure it! View it! Act!

1:30 PM MDT

Prometheus and Grafana form the backbone of modern metrics-based observability, yet many teams struggle to move from “we collect metrics” to “we understand our systems.”

This talk builds a clear mental model for Prometheus and Grafana: how metrics are exposed, scraped, stored, queried, and visualized — and how those metrics connect to real operational decisions. We’ll explore Prometheus architecture, PromQL, Kubernetes integration via the Prometheus Operator, and how metrics power advanced workflows like canary deployments with Argo Rollouts and OpenTelemetry-based telemetry.

Attendees will leave knowing what to measure, how to measure it, and where to start on Monday.

This talk builds a practical mental model for metrics-based observability using Prometheus and Grafana. Rather than focusing solely on dashboards, we’ll explore how metrics are exposed, collected, queried, and ultimately used to make real operational decisions. We’ll connect application-level instrumentation, Kubernetes-native monitoring, and modern telemetry standards, showing how Prometheus fits into today’s production environments and deployment workflows.

• Prometheus Fundamentals
• Application Metrics
• PromQL and Querying Metrics
• Kubernetes and Prometheus
• Grafana Integration
• The JVM: Micrometer, Spring, and Quarkus
• Telemetry and Advanced Use Cases
• Argo Rollouts and Canary Deployments
• What every team should monitor

Identity, Tokens, and Access Control with Keycloak

Practical identity management without rolling your own security

3:15 PM MDT

Authentication and authorization are foundational concerns in modern systems, yet they’re often treated as afterthoughts or re-implemented inconsistently across services.

In this talk, we’ll explore Keycloak, an open-source identity and access management system, and how it fits into modern application architectures. We’ll break down what Keycloak actually does (and what it doesn’t), explain the role of JWTs and OAuth2/OpenID Connect, and examine how identity, trust, and access control are handled across distributed systems.

We’ll also compare Keycloak to secret management systems like Vault, clarify common misconceptions, and walk through integrations you will need with Spring, Quarkus, and other frameworks

By the end, you’ll understand when Keycloak is the right tool, how to integrate it cleanly, and how to avoid the most common architectural mistakes.

In this session, we will define what Keycloak is, its value, and how it integrates with your existing architecture. Here is the layout of the talk:

• “Who are you?” vs “What are you allowed to do?”
• Authentication vs Authorization vs Identity
• Avoiding Rolling your Own Auth(n|z)
• What is Keycloak
• What isn't Keycloak
• Core Concepts
• Review of OAuth2, OpenID, JWT, and Tokens
• Identity Federation
• Difference between Keycloak and Vault
• Where do we put it in architecture
• Integration with Spring, Quarkus, and other Frameworks
• Integration with other Architecture and Components
• What to do on Monday Morning

DataMesh and Open Metadata

Decentralized Data Ownership with Discoverability, Governance, and Trust

5:00 PM MDT

Data Mesh rethinks data architecture in organizations by treating data as a product, owned and operated by bounded context teams rather than centralized platforms. This way, data owners can describe, enrich, and prove data sources to prevent any malicious poisoning.

• A Quick Introduction to DDD
• What is Data Mesh?
• Benefits of Data Mesh
• Data Ownership
• Data Qualifications and Medallions
• Open Metadata
• How to use Open Metadata
• Role of AI in Data Mesh