Daniel Hinojosa

Machine Learning Data Pipelines

9:00 AM MDT

This workshop builds an entire event driven data pipeline with Machine Learning and Kafka. From Kafka where we use producers or Kafka Connect to generate information, we then will Kafka Streams to apply a machine learning model to make business decisions.

This intensive lab will start by integrating sources into our backplane, then train our models, and operationalize our model using Kafka Streams. We will then create result topics when we can read in as a report and display visualizations of our data. The result will also be scalable and fault tolerant.

Java Design Patterns Deep Dive

8:30 AM 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 really excited about this topic and putting it into practice on your own codebase.

Java Design Patterns Deep Dive

10:30 AM 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 really excited about this topic and putting it into practice on your own codebase.

Kubernetes Security Concepts Part 1

9:00 AM MDT

There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.

• Service Accounts
• Secrets
• Kubernetes API
• Authentication
• Authorization
• RBAC
• Roles and Cluster Roles

Kubernetes Security Concepts Part 2

11:00 AM MDT

There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.

Service Accounts
Secrets
Kubernetes API
Authentication
Authorization
RBAC
Roles and Cluster Roles

Project Loom JumpStart

1:30 PM MDT

There is a new way of Threading on it's way to Java, and that means it is time to prepare. Project Loom will be introducing Java Virtual Threads which are small Threads meant to perform quick operations with the need of procuring long-running OS threads which can prove to be expensive. In this class we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, what does it mean for third party libraries.

1. What is a Virtual Thread
2. Creating and Using a Virtual Thread
3. What will Loom's Virtual Threads do to Futures
4. What is a Fiber
5. What is a Continuation?
6. What is a Scheduler?
7. What is Unwind and Invoke? (UAI)
8. Perform Asynchronous Challenges using Project Loom
9. When will it be Released
10. How does it compare to other languages and projects?

Project Loom JumpStart

3:15 PM MDT

There is a new way of Threading on it's way to Java, and that means it is time to prepare. Project Loom will be introducing Java Virtual Threads which are small Threads meant to perform quick operations with the need of procuring long-running OS threads which can prove to be expensive. In this class we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, what does it mean for third party libraries.

1. What is a Virtual Thread
2. Creating and Using a Virtual Thread
3. What will Loom's Virtual Threads do to Futures
4. What is a Fiber
5. What is a Continuation?
6. What is a Scheduler?
7. What is Unwind and Invoke? (UAI)
8. Perform Asynchronous Challenges using Project Loom
9. When will it be Released
10. How does it compare to other languages and projects?

The Java Sessions: Reactive API

5:00 PM MDT

Many have already seen what Reactive Streaming can do: RXJava, Akka Streams, Project Reactor. Now reactive streaming is a part of the canonical package for Java and now we can handle asynchronous pipelines with boundaries and make better well thought out applications

This session introduces you to the core components of Reactive Streams: Publisher, Subscriber, and Processor. We will discuss when to use Reactive Stream and how to avoid complicated scenarios like Backpressure. We will also cover some of the core problem spaces and how to overcome them. After understanding the core interfaces we will see how we use them with RXJava, Akka Streams, Reactor.

• Flow API
• Publisher
• Subscriber
• Subscription
• Processor
• Marble Diagrams
• Libraries Committed to the Flow API
• RxJava
• Project Reactor
• Akka Streams
• Interacting between Libraries

GRAAL The Magnificent!

9:00 AM MDT

Graal is a VM and an awesome VM at that. Able to run a variety of languages and fast. The execution times can be impressive too. This VM can run anything, JavaScript, Python 3, Ruby, R, JVM-based languages like Java, Scala, Kotlin, and LLVM-based languages such as C and C++.

We are living in truly exciting times. So much interesting technology including the VM space. Graal is a virtual machine and shared memory system for multiple languages. GraalVM can either run standalone or embedded in OpenJDK or node.js. Graal can even embed inside databases such as MySQL or Oracle. In the presentation, we look at this exciting VM, how to start it, how to run polyglot applications, and how to integrate all within the same VM.

Grokking Generics

11:00 AM MDT

For those still grappling with Generics. This will be an attempt to clear the air about generics. What are wildcards? What is extends? What is super?  What is covariance? What is contravariance? What is invariance? What is erasure? Why and when do I need this?

Generics or parameterized type is one of the more pain items in any statically typed language on the JVM. This presentation is set to overcome some of these hurdles and understand some of these confusing terms. We will cover the following:

• Covariance
• Contravariance
• Invariance
• Erasure
• Generic Assignments
• Weird Generic Funky Stuf
• Use-Site vs. Declaration-Site Variance
• Differences between Java vs. Scala vs. Kotlin

The Java Sessions: Futures

1:30 PM MDT

Starting with JDK 5, we have had Futures, and they mostly went ignored. Now with concurrency and reactive technology in demand, it is essential that we understand what futures are, and how to handle them and make use of their power in asynchronous systems.

This presentation is a basic ground-up introduction to Futures. We start with Futures and how they came packaged with JDK 5. We take a look at Executors, how to create a thread pool, which pools you should choose. How to model Futures in the JDK and show the difference for awaiting the answer and taking on the answer asynchronously. We also take a look at what a Promise is and when to use one.

• The Standard Future
• How Guava Changed how we work with Future
• Scheduled Futures
• Completion Services
• Completable Futures
• Functional Manipulation