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 (Live): Tools, Gatherers and Constants

Essential Tools, Stream Gatherers, Module Imports and Lazy Constants

8:30 AM MDT

Java is evolving rapidly, not just in performance and scalability, but in how enjoyable it is to write. In this session, we explore recent language and platform features designed to reduce friction, improve expressiveness, and help developers focus on solving problems instead of wrestling with boilerplate.

We’ll cover tools and features such as the Java Almanac and Playground for exploration, Stream Gatherers for building powerful data pipelines, Module Import Declarations to simplify modular development, and Lazy Constants for safer and more efficient initialization. Together, these changes signal a clear direction: Java is becoming more concise, more flexible, and more developer-friendly than ever before.

This session highlights a set of recent Java features that improve everyday development. The focus is on reducing ceremony, improving readability, and enabling more expressive code while staying within familiar Java patterns.

We begin with the Java Almanac and Java Playground, which provide ways to explore the language and quickly experiment with its features. These tools help developers learn, prototype, and validate ideas with less setup.

Next, we cover Stream Gatherers, an enhancement to the Streams API that allows developers to create custom intermediate operations. This makes it easier to express patterns like grouping, batching, and windowing directly within a stream pipeline.

We then explore Module Import Declarations, which simplify working with the Java Module System by reducing verbosity and making dependencies easier to manage. This lowers the barrier to adopting modules in real applications.

Finally, we look at Lazy Constants, which provide a safer and more flexible approach to initializing values only when needed. This improves performance characteristics while maintaining clarity and correctness.

By the end of the session, attendees will understand how these features contribute to a more streamlined Java experience and how they can apply them to write cleaner and more maintainable code

What's New in Java (Live): Concurrency

Virtual Threads, Structured Concurrency, and Scoped Values

10:30 AM MDT

Java’s concurrency model has undergone one of its most significant transformations in decades. This session introduces the core features behind that shift, enabling the development of highly concurrent applications with a simpler, more intuitive programming style.

We will explore Virtual Threads, Structured Concurrency, and Scoped Values. Together, these features allow developers to write code that looks sequential while scaling to handle large numbers of concurrent tasks, with improved clarity, safety, and maintainability.

This session focuses on the modern concurrency features introduced as part of Project Loom. These features change how developers approach parallelism and coordination in Java applications.

We begin with Virtual Threads, which provide lightweight threads managed by the JVM. They allow applications to scale to a large number of concurrent operations without the complexity of thread pools or reactive frameworks. Developers can write straightforward blocking code while still achieving high throughput.

Next, we examine Structured Concurrency, which introduces a way to organize concurrent tasks as a single unit of work. This approach simplifies error handling, cancellation, and lifecycle management by ensuring that related tasks are started and completed together.

We then explore Scoped Values, a safer alternative to ThreadLocal. Scoped Values allow data to be shared across a well-defined execution boundary, making context propagation more predictable and easier to reason about in concurrent programs.

By the end of the session, attendees will understand how these features work together to simplify concurrent programming in Java. They will gain a clear mental model for writing scalable applications using a style that is both readable and robust.

What's New In Java (Live): Simplicity and Vector API

New `main`, Simple Sources, Web servers, Value Objects, and the Vector API

1:00 PM MDT

Java is becoming easier to start with while continuing to push performance forward. This session explores features that simplify how programs are written and executed, as well as APIs that enable more efficient use of modern hardware.

We will cover Simple Source Files and Instance Main Methods, Launching Multi-File Source-Code Programs, the built-in Java WebServer, Value Objects, and the Vector API. These features make it possible to write lightweight applications with minimal setup while still leveraging Java’s performance.

This session focuses on features that reduce the barrier to writing and running Java programs, while also introducing tools for building efficient and high-performance applications.

We begin with Simple Source Files and Instance Main Methods, which remove much of the traditional ceremony required to start a Java program. Developers can write code more directly, making Java more approachable for quick tasks, scripting, and teaching.

Next, we explore Launching Multi-File Source-Code Programs, which allows multiple source files to be executed without a separate compilation step. This enables more realistic applications to be built and run with minimal setup, bridging the gap between simple scripts and structured programs.

We then look at the Java WebServer, a lightweight built-in server for serving content and testing applications locally. This feature makes it easy to spin up a simple server without external dependencies.

After that, we introduce Value Objects, which represent identity-free data and improve both correctness and performance. By focusing on immutable, value-based design, developers can write code that is easier to reason about and better aligned with modern JVM optimizations.

Finally, we examine the Vector API, which provides access to hardware-level optimizations for numerical and data-parallel operations. This allows developers to write code that leverages SIMD capabilities while remaining within the Java ecosystem.

By the end of the session, attendees will understand how Java supports both rapid development and high performance, and how these features can be combined to build applications that are simple, efficient, and modern.

What's New in Java (Live): Language and Native Interop

Primitive Patterns, Flexible Constructors, Foreign Functions

3:00 PM MDT

Java continues to evolve its language features while expanding its ability to interact with native code. This session focuses on improvements that make Java more expressive and flexible, as well as capabilities that bring it closer to the underlying system.

We will explore Primitive Patterns in instanceof and switch, Flexible Constructor Bodies, and the Foreign Function and Memory (FFM) API. These features improve how developers write conditional logic, construct objects, and integrate with native libraries, all while maintaining Java’s focus on safety and clarity.

This session highlights language and platform features that enhance expressiveness and extend Java’s reach beyond the JVM.

We begin with Primitive Patterns in instanceof and switch, which expand pattern matching to support primitive types. This allows developers to write clearer, more concise conditional logic, reducing boilerplate and improving readability in common control-flow scenarios.

Next, we explore Flexible Constructor Bodies, which relax previous constraints on constructor structure. Developers can perform logic before delegating to another constructor or superclass, enabling more natural object initialization and better alignment with real-world design needs.

Finally, we examine the Foreign Function and Memory (FFM) API, which provides a modern and safe way to interact with native code and memory. This API replaces many of the complexities of JNI, allowing Java applications to call native libraries and manage off-heap memory with greater clarity and control.

By the end of the session, attendees will understand how these features make Java more expressive as a language and more powerful as a platform, opening the door to cleaner code and new types of applications.

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