Daniel Hinojosa

What's New In Java Half-Day Part 1

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

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

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

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

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

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?

Where Is My Saga and Other Observability Delights

Understanding progress, failure, and visibility in distributed systems

Modern distributed systems don’t fail loudly; they fail invisibly and quietly. Work spans services, hops across messages, and unfolds over time, making it difficult to answer simple questions like: where are we right now?

In this talk, we’ll explore observability as a design discipline, not just a monitoring concern. Using Saga patterns, both choreography and orchestration, we’ll see how metrics, logs, and traces allow us to reconstruct causality, track long-running business workflows, and surface meaningful system state. We’ll go beyond dashboards to show how observability data can be turned into fitness functions that continuously validate architectural assumptions in production.

• The Observability Problem We Actually Have
• Why Distributed Systems Are Hard to See
• Saga Patterns
• Choreography vs Orchestration
• Signals of Observability: Metrics, Logs, Traces
• Open Telemetry
• Distributed Tracing
• Creating Dashboards
• Observability to Fitness Functions
• Alerts and Canary Analysis

Java Testing Lab: Test Driven Development (with Ai)

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)

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!

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

DataMesh and Open Metadata

Decentralized Data Ownership with Discoverability, Governance, and Trust

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

Identity, Tokens, and Access Control with Keycloak

Practical identity management without rolling your own security

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

Hexagonal Architecture

Putting Code in the Correct Place

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

Putting Code in the Correct Place

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.