Nix: Sandbox and Reproducible Builds

We have gone through a lot when configuring our computers with a language, with an editor, and maybe even setting up Git. For every project, though, we may need a different set of tools. In one, you may require Java 17 with a particular version of Kotlin. Another will require an `npm` of a specific version. You could use something like SDKMan for Java or a node version manager for Node. The problem is that you must install it and ensure you do it correctly for every project. The global installation won't cut it; the more complex your project dependencies, the more tedious it will get. Nix provides consistent installation of tools so that it gets it right every time and for every project. It manages all project dependencies so you can consistently build your project.

In this presentation, we will cover:

* What is Nix, and why is it useful?
* How is it different from using Docker or any other container environment?
* How to install
* What is the actual operating system?
* How to use `nix-shell`?
* How to create an environment
* Using Nix
* Finding and using flakes
* Programming Nix
* Using Nix with Docker
* How dependencies are cached
* How to integrate it with your project
* What does Nix mean for CI/CD environments?

MLOps: Operationalizing ML

This presentation discusses how to operationalize model and machine learning operations. We will discuss versioning, containerizing, and deploying models, applying CI/CD practices to models, creating streaming operations, monitoring, and live training. We will also look at platforms that are currently in use and how they are applied in
modern architectures.

Gentle Introduction To Neural Networks

In this presentation, we will introduce neural networks, and we will take it slowly. We first describe the process of learning machine learning. We will then go into the tools typically involved with machine learning and neural networks. The core of this presentation is taking small steps to achieve a big goal: an understanding of a neural network. What is a neuron? What is a tensor? What are weights? What are biases? What is backpropagation? Why do the networks have such funny shapes? ML and AI are here to stay; let's start embarking on this frontier.

Canary Deployments

Canary Deployments are the last ingredient of any Continuous Delivery or Continuous Deployment rollout. A canary deployment is a deployment strategy that releases an application or service incrementally to a subset of users. All infrastructure in a target environment is updated in small phases (e.g., 2%, 25%, 75%, 100%). This control makes a canary release the lowest risk-prone compared to all other deployment strategies, like the blue-green strategy. If you need to back out of a production deployment quickly without much disruption, then canary deployments may be an excellent practice to set up.

We will treat this talk like a recipe so that you can set up a canary in your work environment.

* Continuous Integration, Continuous Delivery,
* Continuous Deployment Overview
* You can perform this anywhere: Cloud instances or Kubernetes
* What is Canary? What are some of the strategies you can use?
* What CD Frameworks perform Canary Deployments?
* How do you perform metrics? Are things going too slow or too fast?
* How do you back out if this rollout is not performing as well as it should?
* Can you perform canary deployments without a CD framework? Perhaps something native to Kubernetes?
* Demonstration using Spinnaker
* Conclusion

What's new in Scala 3

Let's take a look at some of the cool new stuff that we can use. This presentation will assume basic Java knowledge and no Scala knowledge is required.

Our presentation will do a quick little intro, and then we will proceed right into some of the new features.

Trait Parameters
New Implicit Forms for Typeclasses
Inferable Parameters
Extension Methods
Creator Applications
Actual Enumerations and Abstract Data Types
Again, worth reiterating, no previous Scala knowledge required. Bring questions and your curiosity!

TypeLevel Cats

Imagine toString, equals, and hashCode in a single class. Can you change implementations on the spot? Probably not, there may be too many dependencies on your implementation. Time to break out an adapter pattern, a utility class, or better yet, a type class! A type class is a kind of template in very static functional programming languages. Imagine a template that can read, write information as a side effect as well? Type classes are powerful.

For these various type-classes, we will be looking at a project called TypeLevel Cats. TypeLevel is a group of projects that adhere to a code of conduct, modular systems, static, functional, open-source programming. TypeLevel Cats is the flagship project for Typelevel.

Our presentation will be following this story:

Just a tiny bit of Scala
Introduction to an implicit
Introduction to a typeclass
Using Cats
Eq
Monoid
Monad
Functors

Even if you are not a Scala Programmer, you may want to come in and see how type classes work because I am making a bet… This will be something that will be used by other JVM languages in the future. Kotlin doesn't have it now, Groovy doesn't have it now, TypeScript doesn't either although some projects are working towards this idea.

The Interpreter Pattern in Light of Java 21

Java 21 is out! Can you believe it? It's been a long time since I tried Java 1.0 in 1996. It has been amazing how much advancement has happened in Java over the years. Another monumental milestone was the book Design Patterns: Elements of Reusable Object-Oriented Software, also known as the "Gang of Four" book, released in 1994. Both are products of their times, using 1990s languages and tools. It's now 2023, and we have seen some things. Java now uses lambdas and streams extensively. We now desire immutability. Java's garbage collection has vastly improved by leaps and bounds. So, while Java has undoubtedly changed, how about our design patterns? That's why we will discuss one of the patterns from the "Gang of Four" book, the Interpreter Pattern. How do new features like sealed classes, pattern matching, records, and enhanced switch statements in today's Java change the interpreter pattern? Why is the interpreter so sought out among functional programmers? We will review the classic pattern and its purpose. We replace it with a modern alternative using the latest Java 21 techniques. We discuss its importance and use and how to wire in concepts like programs and monads, thus pushing our knowledge to Java's edge!

Testing Legacy Code

In reality, our jobs aren't dealing with new code, but old crufty and evil code. How do we test such code, how do we get through it? How can we surgically take some of this bad code apart and make it testable? How can we move away from mocking?

This presentation looks at bad code and we talk about some of the strategies that we can do to diagnose, test, apply, and finally refactor to produce something that would promote some sanity in your development process. The content of this course is all in Java and Junit.

Personal Productivity with the Pomodoro Technique

Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it’s done with a kitchen timer.

In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.

Next Gen Testing Tools for Java

We have been using JUnit and doing TDD for years, but you can take testing further. In this session, we will discuss some tools you absolutely need for testing your code outside of the regular stack you currently use.

* Property-Based Testing with JQwik
* Mutation Testing with PITest
* Databases Testing with Test Containers
* Testing Web Services with RestAssured
* Testing Asynchrony with Awaitly

We will also finish with some testing components that we have been using for years that you may have not heard about just to ensure we are level set as a community, like Mockito, AssertJ.

Machine Learning Data Pipelines with Kafka and Tensorflow

An intense presentation designed to operationalize machine learning. This talk focuses on dividing specializations; data engineer and data scientist.

The data engineer ensures that data is delivered, manipulated, and harnessed. The data engineer does this to be useful for the data scientist. The data engineer is also versant in Java and Scala and will be knowledgeable in pub-subs like Kafka.

The data scientist uses that data, does their cleaning, and investigates possible patterns designing a machine learning model that we can use to either find regressions or classifications for our data. The data scientists use Python, Jupyter Notebooks, Tensorflow, and Matplotlib as their tools of choice for constructing a machine-learning model to make decisions about the data.

This presentation answers the question. How do we take that model and tie it to everything else? This workshop will use a wide array of technologies. It will set you on the path to running Machine Learning Pipelines in Kubernetes using Kafka and Tensorflow, so you can start immediately when you return to work.

Java Design Patterns with a Modern Functional Flair

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.

Harnessing Data Stores with Kafka Connect

In this presentation, we will discuss Kafka Connect. Kafka Connect is an open-source project from Confluent to either take information from a data store as a Source or possibly dump information into another datastore, a Sink.

What this presentation will entail:

A brief overview and review of Kafka
The Architecture of Kafka Connect
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.

Grokking Generics

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?

One of the more pain items in any statically typed language on the JVM is generics or parameterized type. This presentation is set to overcome some of these hurdles and understand some of these terms that often vex us. We will cover:

* Covariance
* Contravariance
* Invariance
* Erasure
* Generic Assignments
* Weird Generic Funky Stuf
* Use-Site vs Declaration-Site Variance

Architectural Design Patterns Deep Dive

In this day-long work workshop, we will review a catalog of all the standard architectural design patterns. For each design pattern, we will run docker-compose files that demonstrate the strengths and weaknesses of those design patterns. So, you have a first-hand, full-on, and highly engaged full-day workshop to give you the knowledge you need to make critical architectural choices.

All labs and examples will be using docker-compose. The examples that we will be focusing on in this intensive workshop include:

* Hexagonal Architecture
* Domain Driven Design
* Circuit Breaker
* Retry
* Bulkhead
* Ambassador
* Event Sourcing
* Competing Consumers
* Claim Check
* Materialized Views
* CQRS (Command-Query Responsibility Segregation)
* Strangler Fig
* Gatekeeper
* Valet Key
* Saga Pattern
* Data Mesh

Continuous Delivery on Kubernetes with Spinnaker

Back in 2005, when an unknown program called Hudson came onto the scene, I was pretty excited. I had used CruiseControl up to that point and was getting pretty comfortable with the notion of Continuous Integration.

Hudson had terrific graphics and an intuitive UI, unlike Cruise Control with XML-laden directives. I thought the future was here. Then some cracks started showing, particularly in the delivery aspect of Hudson. I had used a Tomcat plugin, but trying to get a jar, use various environments, became a juggling act.

Then came Docker, and I loved it because we get to deploy an image! No more SSHing into a box and messing things up. We had immutability.

Now, we have Kubernetes, a system that takes these immutable containers and monitors them, among other great features.
Jenkins still has its place but as CI, Continuous Integration. In this presentation, I will demonstrate Spinnaker, a system developed by Netflix for CD, Continuous Delivery. I will demonstrate how to set up, deploy, monitor, rollback, and scale our pods with the ease of just selecting an item on a menu.

Nix: Sandbox and Reproducible Builds

We have gone through a lot when it comes to configuring our computers with Java, with an editor, and maybe even setting up Git. We often take great care in ensuring that our PATH and even JAVA_PATH environments are clean and organized. Then, when we decide to install software that depends on the software that we already have installed, what does it do, reinstall that dependency! Not only that, it's somewhere else. Now we have multiple Java's with the same version. We have multiple pythons, Multiple everything. It's time to end this madness and aggravation and nix the old way and introduce the new way, Nix.

In this presentation, we will cover:

* What is Nix, and why is it useful?
* How is it different from using Docker or any other container environment?
* How to install
* What is the actual operating system?
* How to use `nix-shell`?
* How to create an environment
* Using `nix`
* Nix flakes
* NixOS
* Using Nix with Docker
* Nix Store
* How to integrate it with your project
* What does Nix mean for CI/CD environments?