Human AI collaboration: Making Prudent use of AI in development

The power of AI is incredible and learning to make good use of it is in the best interest of both developers and organization.

In this workshop, we will start with a very short discussion of ethics, legality, and the risks of using AI to assist with software development Then we will spend most of our time with hands on exercises. We will take a problem, spend a few minutes collaborating with humans to solve it. Then we will use AI tools to solve it. We will compare notes and learn the effectiveness of both types of collaborations—with humans and with AI.

Fundamentals of Migration Engineering with OpenRewrite

How adaptable is your technology stack to changes in business requirements, technological advancements, and the availability of new and better tools (and avoiding vendor lock-in!)?

When you can more easily secure, upgrade, move, or modernize your code, that means you can adapt quickly and efficiently to changes in technology and markets. That’s what Migration Engineering is all about, which we’ll be exploring in this workshop.

We’ll discuss and demonstrate how to write custom recipes using OpenRewrite, an open source auto-refactoring tool, to study and analyze your code before planning migration and modernization efforts—and then automate code changes for your teams.

You’ll also learn how to write recipes that will automate code search and transformation actions that are custom to your organization. We will assemble these recipes with the visitor pattern, show how to stitch recipes together with YAML, with Refaster-style templates, with Semgrep matchers, etc. This is a comprehensive look at all kinds of recipe development.

You will come away fully equipped to plan and exercise large scale code transformations in your organization.

Outline:

• What is Migration Engineering? (15 minutes)
• Introducing OpenRewrite (30 minutes)
• Recipe Exercise #1: Change all integer literals to 42 (because 42 is the answer to life, the universe, and everything) (30 minutes)
• Recipe Exercise #2: Fixing SAST issues with Refaster-style templates (30 minutes)
• Recipe Exercise #3: Finding and securing Personally Identifiable Information (1 hour)
• Recipe Exercise #4: Finding and fixing SQL injection (1 hour)
• Mass remediation: Using our first recipes to issue pull requests or commits to many repositories at once (15 minutes)
• Visualization #1: Visualizing the distribution of Gradle versions in a codebase (30 minutes)
• Visualization #2: Visualizing unused binary dependencies in Maven and Gradle projects (30 minutes)
• Where to integrate Migration Engineering into the SDLC (15 minutes)
• Open recipe development lab (1.5 hours)

Upgrade to Modern Java: 2025 Deep Dive

Over the past few years, the basic idioms and recommended programming styles for Java development have changed. Functional features are now favored, using streams, lambda expressions, and method references. The new sixmonth release schedule provides the language with new features, like modules and local variable type inference, much more frequently. Even the new license changes in the language seem to complicate installation, usage, and especially deployment.

The purpose of this training course is to help you adapt to the new ways of coding in Java. The latest functional approaches are included, including using parallel streams for concurrency, and when to expect them to be useful. All the new significant features added to the language will be reviewed and evaluated, with the goal understanding what problems they were designed to handle and when they can be used effectively in your code.

Certified Kubernetes Application Developer (CKAD) Crash Course

The ability to use, troubleshoot, and monitor Kubernetes as an application developer is in high demand. In response, the Cloud Native Computing Foundation (CNCF) developed the Certified Kubernetes Application Developer (CKAD) program to establish credibility and value in the job market. The exam is different from the typical multichoice format of other certifications. It’s completely performance based, under immense time pressure, and requires deep knowledge of the tasks.

This full day hands-on workshop walks you through all the topics covered in the exam to fully prepare you to pass with flying colors. The course is suitable to beginners to Kubernetes. You'll learn when and how to apply Kubernetes concepts to manage an application.

I'll hand out print copies of the book “Certified Kubernetes Application Developer (CKAD) Study Guide: In-Depth Guidance and Practice, 1st Edition” for questions from the audience. I'll also provide a free 30-day trial access to the O'Reilly learning platform to read the 2nd edition of the book.

We'll cover the following topics and more:

• Pod and Namespace Management
• Multi-Container Pods
• Probes and Health Checks
• ConfigMaps and Secrets
• State Persistence
• Deployments and Deployment Strategies
• Custom Resource Definitions (CRD)
• Authentication, Authorization via Role-Based Access Control (RBAC)
• Services and Networking
• Troubleshooting Scenarios

GitHub Copilot Deep Dive

GitHub Copilot is a generative AI tool for coding that assists developer in writing code more efficiently and faster. This full-day course will help you gain a comprehensive understanding of the tool's capabilities and how to use it effectively in your day-to-day coding.

In this full-day class, we'll cover the basics of Copilot and provide you with hands-on experience through labs. You'll learn the what, why, and how of Copilot and see how to leverage its generative AI functionality in daily coding tasks across multiple languages. You'll also learn key techniques and best practices for working with Copilot.

IMPORTANT NOTE: In order to do the labs for this course, you must have a GitHub Copilot subscription. If you do not, you can log into GitHub, then go to https://github.com/settings/copilot and sign up (start free trial) before the course.

API Design

Application Programmer Interfaces (APIs) by definition are directed at software developers. They should, therefore, strive to be useful and easy to use for developers. However, when engaging design elements from the Web, they can be useful in much larger ways than simply serializing states in JSON.

There is no right or perfect API design. There are, however, elements and choices that induce certain properties. This workshop will walk you through various approaches to help you find the developer experience and long-term strategies that work for you, your customers and your organization.

We will cover:

The Web Architecture as the basis of our APIs
The REST Architectural Style and its motivations
The Richardson Maturity Model as a way of discussing design choices and induced properties
The implications of contentnegotiation and representation choices such as JSON or JSONLD
The emergence of metadata approaches to describing and using APIs such as OpenAPI and HydraCG
Security considerations
Client technologies
API Management approaches

Domain Driven Design Deep Dive

Domain Driven Design has been one of the major cornerstones in large system design for many years. It has recently been in the zeitgeist as of late, especially when it comes to the terms bounded context and microservices. This full-day class introduces you to Domain Driven Design, and why it is important. We will cover the design and pattern, discuss subdomains, context mapping, tools, and management

Our workshop will not only introduce you to the terms, but we will cover planning, and go through challenges on design so we can discuss the tradeoffs that come with the design. We will also cover some of the more modern patterns that came out of DDD like CQRS, Data Mesh, Rest, and more.

Personal Knowledge Management (PKM) for the Modern Knowledge Worker

Join us for a transformative handson workshop on Personal Knowledge Management (PKM), designed specifically to empower developers, architects, and knowledge workers alike to master information in this information age. Based on Tiago Forte's Building a Second Brain methodology and implemented using the Logseq PKM application, this course aims to equip attendees with the strategies, tools, and insights to streamline their knowledge management, increase productivity, and stimulate creativity. Attendees will learn to construct a personal knowledge graph, effectively annotate and reference digital assets, manage tasks, journal for success, leverage templates, and much more. The ultimate goal is to create a personalized system that enables you to instantly find or recall everything you know and learn.

Throughout this fullday, handson workshop, you will be guided to apply the concepts and practices learned to build your own personal knowledge graph. By the end of the session, you will have a comprehensive system to manage your knowledge effectively, enabling you to spend less time searching for notes or lost information and more time utilizing what you know and learn.

This workshop isn't just about learning new concepts or tools; it's about transforming your relationship with information and your productivity. The skills and practices you will learn are universally applicable, irrespective of the tools you use. We will show you how these methods work in Logseq, but the principles can be adapted to other platforms as well.

Join us for this transformative journey, and experience a significant shift in how you manage and utilize your knowledge, leading to increased productivity, creativity, and overall wellbeing in your personal and professional life.

Bring your curiosity, your questions, and your goals. We look forward to seeing you at the workshop!

Advanced Git

You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?

The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.

In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.

By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.

Building Intelligent Spring Applications with Spring AI

By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.

So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.

For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot autoconfiguration, you'll be able to get straight to the point of asking questions and getting answers your application needs.

In this handson workshop, you'll build a complete Spring AIenabled application applying such techniques as prompt templating, Retrieval Augmented Generation (RAG), conversational history, and tools invocation. You'll also learn prompt engineering techniques that can help your application get the best results with minimal “hallucinations” while minimizing cost.

DIY Gen AI: Running LLMs locally with LM Studio, Hugging Face, and Ollama

Updated! LM Studio is an easy to use desktop app for experimenting with local and open-source Large Language Models (LLMs) by hosting them on your own system.
Here are some of the features it provides (quoted from its homepage):

Run LLMs on your laptop, entirely offline
Use models through the in-app Chat UI or an OpenAI compatible local server
Download any compatible model files from HuggingFace repositories
Discover new & noteworthy LLMs in the app's home page

Hugging Face is a community hub focused on creating and sharing AI models. It provides many free and pre-trained models as well as datasets and tools to use with them.

Ollama is a command line tool for downloading, exploring, and using LLMs on your local system.

In this hands-on workshop, we'll cover the basics of getting up and running with LM Studio, Ollama and give you hands-on labs where you can use them and Hugging Face to find and load and run LLMs, interact with it via Chat and Python code and more!

Join author, trainer and speaker Brent Laster to learn about LM Studio, Hugging Face, Ollama, and Streamlit and how to use them to find and use Large Language Models hosted and running in your own environment. Get hands-on experience with the applications and learn how to DIY your own Gen AI!

Agenda:

Section 1: Introduction

In this section, we'll talk about what LLMs are, learn about basic use of LM Studio to find models and also start to look at huggingface.co.

Lab 1 - Lab 1 - Getting familiar with LM Studio and models

Purpose: In this lab, we’ll start to learn about models through working with one in LM Studio.

Section 2: Chatting with LLMs and using their APIs

In this section, we'll learn about how we can chat with an LLM, the different roles involved in chatting, and how to also use API calls from the command line to interact with models.

Lab 2 - Chatting with our model

Purpose: In this lab, we'll see how to load and interact with the model through chat and terminal.

Section 3 - Programming for local models

In this section, we'll look at how to create some Python code to interact with LM Studio with its lms interface and lmstudio.js library for JavaScript and Typescript.

Lab 3 - Coding to LM Studio

Purpose: In this lab, we'll see how to do some simple Python and JavaScript code to interact with the model.

Section 4 - Leverage HuggingFace.co

In this section, we'll look more into the model details and tools for using models that Hugging Face offers, including its transformers library and pipelines.

Lab 4 - Working with models in Hugging Face

Purpose: In this lab, we’ll see how to get more information about, and work directly with, models in Hugging Face.

Section 5 - Using Ollama

In this section, we'll learn about how we can use the standalone tool Ollama to get and run LLMs. We'll also talk about multimodal models.

Lab 5 - Using Ollama to run models locally

Purpose: In this lab, we’ll start getting familiar with Ollama, another way to run models locally.

Section 6 - Creating simple UIs for GenAI with Streamlit

In this section we'll work with a graphical Python library, Streamlit to see how to quickly and easily create interactive interfaces like chatbots to use with our local LLMs.

Lab 6 - Building a chatbot with Streamlit

Purpose: In this lab, we'll see how to use the Streamlit application to create a simple chatbot with Ollama.

Go for Java Developers

Looking to go beyond the basics of Go. In my Golang for Java developers we teach the basics of Go while building out different labs to demonstrate an understanding of the concepts.

This session is the next stage of more deeply understanding some of the more advanced or new features in Golang which include:

• Concurrency
• Channels
• Error Handling
• Generics
• WASI
• New 1.20 and 1.21 language features

How Do You Get AI Into Production?

In the ever-evolving landscape of technology and Generative AI, integrating DevOps principles into the machine learning (ML) lifecycle is a transformative game-changer.

Join me for an insightful session where we will explore essential aspects such as mlflow, deployment patterns, and monitoring techniques for ML models. Gain a deeper understanding of how to effectively navigate the complexities of deploying ML models into production environments. Discover best practices and proven strategies for monitoring and observing ML models in real-world scenarios.

By attending this session, you will acquire valuable insights and practical knowledge to overcome the unique hurdles of scaling and bringing AI into production. Unlock the full potential of your ML models by embracing the powerful integration of DevOps principles. This presentation is based on the extensive customer research I conducted to write the Best Seller book - Scaling Machine Learning with Spark - https://www.amazon.com/Scaling-Machine-Learning-Spark-Distributed/dp/1098106822.

Java Design Patterns To Go

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 excited about this topic and putting it into practice on your codebase.

Kafka Fundamentals

Kafka is a “must know.” It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs. As such, Kafka has become an essential product in the microservice and big data world.

This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.

Practical AI Tools for Java Developers

This talk will be tailored to Java developers as we delve into the practical applications of AI tools to ease your software development tasks. We'll explore the capabilities of GitHub Copilot used as a plugin for IntelliJ IDEA and VSCode. We'll also play with GPT4 and examine ways it can help.

It's often said that AI tools will not replace existing developers, but that a developer with those tools will have an advantage over developers without them. Join us as we try to demystify the world of AI for Java developers, equipping you with practical skills to incorporate these tools into your development workflow. Note that this is a rapidly changing field, and the talk will evolve to work with the latest features available.

Spring Graph QL

In this example-driven session, we're going to look at how to implement GraphQL in Spring. You'll learn how Spring for GraphQL builds upon GraphQL Java, recognize the use-cases that are best suited for GraphQL, and how to build a GraphQL API in Spring.

Typical REST APIs deal in resources. This is fine for many use cases, but it tends to be more rigid and less efficient in others.

For example, in an shopping API, it's important to weigh how much or how little information should be provided in a request for an order resource? Should the order resource contain only order specifics, but no details about the order's line items or the products in those line items? If all relevant details is included in the response, then it's breaking the boundaries of what the resource should offer and is overkill for clients that do not need it. On the other hand, proper factoring of the resource will require that the client make multiple requests to the API to fetch relevant information that they may need.

GraphQL offers a more flexible alternative to REST, setting aside the resource-oriented model and focusing more on what a client needs. Much as how SQL allows for data from multiple tables to be selected and joined in response to a query, GraphQL offers API clients the possibility of tailoring the response to provide all of the information needed and nothing that they do not need.

Techniques for the worst of legacy code: Peel and Slice

The system crashes in a portion of the codebase you have never seen. It is Friday night, 4 o'clock pm, and you have to fix it before you can go home. How can you accelerate your understanding of the bug and still get out of the office before 5?

Learn to use two simple techniques to isolate the problem by dividing and conquering code without necessarily understanding it. Once the problem has been isolated you will have a suite of tests that replicate the error, and allows you to simply debug to find the problem. After the problem is found, and you have tests replicating the error, you will have everything you need to fix it.

The Java Memory Model Clarified

One of the features that distinguished Java from a majority of mainstream languages at the time it was released was that it includes a platform independent threading model.
The Java programming language provides core, low-level, features to control how threads interact: synchronized, wait/notify/notifyAll, and volatile. The specification also provides a “memory model” that describes how the programmer can share data reliably between threads. Using these low-level features presents no small challenge, and is error prone.

Contrary to popular expectation, code written this way is often not faster than code created using the high level java.util.concurrent libraries. Despite this, there are two good reasons for understanding these and the underlying memory model. One is that it's quite common to have code written in this way that must be maintained, and such maintenance is impractical without an understanding of these features. Second, when writing code using the higher level libraries, the memory model, or more specifically, the “happens-before” relationship still guides how and when we should use these libraries.

This workshop presents these features in a way designed to allow you to perform maintenance, and write new code without being dangerous.

Third Way Web Development with HTMX

When the world wide web launched in 1993, it presented a revolutionary new way to globally share information. The revolution didn't stop there. The web soon became a platform for building, hosting, and distributing entire applications. Today most applications are built as web applications yet the core capabilities of HTML remain mired in the Web 1.0 days. Ajax was the first of many “hacks” to build web applications that delivered the rich, responsive user experience that rivaled traditional fatclient applications. Early js libraries and frameworks overcame browser incompatibilities and provided the first abstractions to hide the hacks and today's frameworks are so powerful that conventional wisdom states they are the defacto best practice for building modern web applications. But at what cost?

We've gone fullcircle. Today's SPAs have more in common with the fat client applications of the 90s (albeit with simplified deployment) than they do with the web. The modern UX of today's frameworkdriven SPAs is what users demand, thus we follow the everchanging trends; but at what cost? Beyond the bloat, complexity, and ephemerality of the modern webdev toolchain; modern webdev practices have inadvertently abandoned the core ideas of the web that made the platform technologically, architecturally, and philosophically revolutionary.

Leading thinkers in the web development space have long proclaimed that “not everything should be a SPA” however the alternative of a web 1.0 vanilla html application has very limited utility in the year 2024. Are these our only options, or does a “third way” exist?

This session introduces that “third way” based on the revolutionary ideas that empowered the web. A meaningful, practical, and proven alternative to SPA frameworks providing a simpler and more lightweight approach to building applications on the Web and beyond without sacrificing the UX.

Web applications built following this “third way” boast more evolvability, longevity, and simplicity. SPAs will continue to have their place, but good software engineering is about using the right tool for the job. After attending this session, you will have more than just a hammer in your toolbox.

Vector Databases : Accelerating Learning and Discovery

If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.

This will be an overview of the benefits of vectors databases as well as an introduction to the major players.

We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.

We will cover:

• A brief overview of vectors
• Why vectors are so important to machine learning and datadriven systems
• Overview of the offerings
• Adding vector search to other systems
• Sample use cases shown with one of the key open source engines

What's New in Spring and Spring Boot

In this example-driven session, we'll review several tips and tricks to make the most out of your Spring development experience. You'll see how to apply the best features of Spring and Spring Boot, including the latest and greatest features of Spring Framework 6.x and Spring Boot 3.x with an eye to what's coming in Spring 7 and Boot 4.

Spring has been the de facto standard framework for Java development for nearly two decades. Over the years, Spring has continued to evolve and adapt to meet the ever-changing requirements of software development. And for nearly half that time, Spring Boot has carried Spring forward, capturing some of the best Spring patterns as auto-configuration.

As with any framework or language that has this much history and power, there are just as many ways to get it right as there are to get it wrong. How do you know that you are applying Spring in the best way in your application?

When Things Go Wrong

One of the more troublesome parts of creating good quality software is how we handle problems that interrupt the “happy path”. Exacerbating this problem, most of our design methodologies don't seem to offer much advice on the topic. In this session we'll investigate some general categories of failure and consider the macro behaviors that are appropriate to each and where–in terms of the call stack–those actions should be taken.

The discussion will compare the strengths and weaknesses of the most common ways of representing failure: sentinel values, exceptions (both Java's checked variant, and the more common unchecked approach), and the functional technique based on monads. Along the way, we'll consider the abstraction of error, the consequences of getting this design aspect wrong, and how the design of our APIs might make errors less common in the first place.

\s+[Rr]eg(ular [Ee]xpression|ex[pe]?)s? for Mortals (Workshop)

Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages once you know regular expressions you will find a use for them in almost every programming context.

In this highly interactive workshop we will decipher the cryptic construct that is a Regular Expression. Starting with the basics, we will work our way towards advanced usage, including anchors, modifiers, groups, and look arounds.

This is a HIGHLY interactive workshop — Not only will we have a lot of exercises, we will use a playground that will allow us to experiment to our heart's content! Feel free to come in with issues you may have seen at work!

Agenda:
The basics and how to read regular expressions
Character Classes
Negation
Ranges
Shortcuts
Alternations
Repetitions
Word Boundaries
Capture Groups
Anchors
Modifiers

Let's once and for all make sense of this powerful tool.

I hope to see you all there.