Rediscovering Apollo 11: Using Java + Vector Search to Explore the trip to the moon!

What happens when you combine the Apollo program’s historical data with modern AI tools? You get a way to interact with one of humanity’s greatest adventures like never before! In this session, I’ll show you how I used AI to explore Apollo mission data—aligning transcripts, telemetry, and images to uncover hidden connections and insights.

We’ll dive into how Semantic Search helps make sense of unstructured text, why embeddings are the key to searching for intent instead of keywords, and how AI tools can enrich even the most complex datasets. Don’t know what embeddings or vector databases are? Don’t worry—I’ll break it all down and show you how it works.

Come for the Moon missions, stay for the AI magic, and leave ready to create your own data-driven adventures!

From Data to Insights: Building a Bluesky Bot powered by AI

A common challenge developers face when working with data streams is collecting and analyzing this data as fast as possible to uncover meaningful insights. It’s a complex problem that requires the right combination of real-time data technologies and AI for instant, intelligent decision-making.

In this talk, I’ll show you how I tackled this by building a Bluesky bot that turns raw data into actionable insights using GenAI. We’ll dive into the process of collecting data, transforming it into streams, and using Redis 8 to power real-time analysis. Along the way, I’ll explore how probabilistic data structures, like Count-Min Sketch and Bloom Filters, help optimize performance and enable scalable analytics without compromising accuracy.

I’ll also demonstrate how Redis 8 supports vector similarity search, making it possible to compare and classify data efficiently—an essential step for enhancing AI-driven insights. You’ll see how this can be applied to find patterns, group similar content, and make smarter recommendations.

Finally, I’ll bring it all together by showing how Redis and GenAI work hand in hand to extract patterns and generate insights, with practical examples implemented in Java.

Whether you’re curious about GenAI, interested in data-driven analytics, or simply love experimenting with creative tech solutions, this session will inspire you with practical techniques and real-world applications.

Devoxx Belgium: https://youtu.be/WXXsS4k2qMI?si=U4gh5HPruFmHHqOV

Spring IO: https://youtu.be/DylvTW_ia4Y?si=Rz-OWsf_6uBYkY18

Beyond Coding Podcast: https://youtu.be/aF7Pcvn0CdI?si=SwomwFaEWrPFVwGP

TedXKE: https://youtu.be/gJKuqonxRJQ?si=91zKMrZ1lqq4ePgf

WORKSHOP: From Data to Actionable Insights: Building a Bluesky bot powered by SpringAI

Streams are a powerful way to collect and analyze data at high speed, enabling developers to uncover meaningful insights and take immediate actions. But working with streams and transforming raw data into actionable information can be challenging, especially when performance and scalability are critical.

In this workshop, we’ll tackle these challenges by building a Bluesky bot that processes data from Bluesky’s stream of posts into actionable insights using Redis, Spring AI, and Redis OM Spring—a powerful combination for modern, data-driven applications.

AGENDA
During this workshop, you will work with practical examples and hands-on exercises to learn how to:
- Collect data into streams using Redis Streams.
- Leverage probabilistic data structures like - Bloom Filters, TopK, and Count-Min Sketch for efficient data summarization.

Use a Vector Database to:
- Implement Retrieval-Augmented Generation (RAG) to enhance your LLM queries with a personalized knowledge base.
- Reduce costs and improve performance using semantic caching for minimizing unnecessary LLM calls.
- Perform vector similarity search with Redis OM Spring to classify and analyze data effectively.

And finally:
- Query your data efficiently for actionable insights.
- Ensure scalability and reliability.

This is an interactive workshop. We will be learning while iterating over real challenges. Don’t forget your laptop!

AsyncAPI & Springwolf - Automated documentation (and more)

AsyncAPI is an open-source initiative that provides a specification to standardize the documentation of event-driven APIs, much like the OpenAPI specification does for REST APIs.

Springwolf, on the other hand, is a practical implementation of the AsyncAPI specification, specifically tailored for Spring Boot applications. It automates the process of documenting event-driven systems, ensuring that the documentation is always synchronized with the actual state of the application.

In this talk, we will focus on learning how Springwolf can help us design and maintain accurate, protocol-agnostic API documentation, automate the generation of AsyncAPI specifications, and provide clear insights into the interactions and functionalities of our event-driven systems, enhancing collaboration and understanding among developers.

This session has been recently delivered at Spring IO 2024:
https://2024.springio.net/sessions/asyncapi-and-springwolf-automated-documentation-and-more/

Show your Work & Become Findable

In today's digital age, it's easier than ever to create and share our work with the world. But with so much content out there, how do you make your creative endeavors stand out?

In "Show Your Work!," author and artist Austin Kleon offers practical advice for anyone looking to share their creative process, build an audience, and connect with like-minded individuals.

In this talk, we'll go through one of the articles I wrote and show how I was able to apply a few of the key lessons from Kleon's book and discuss how we can apply them to our own creative journey.

Exceptions in Kotlin: Beyond the Try/Catch

This session is ideal for those transitioning from Java to Kotlin and seasoned Kotlin developers eager to refine their error-handling strategies.

This session engages you in both practical knowledge and a philosophical discussion on error handling in Kotlin, covering best practices and the rationale behind Kotlin's design philosophy.

We begin by examining common patterns in transitioning from Java to Kotlin, focusing on their impact on exception handling. This sets the stage for exploring Kotlin's advanced error-handling mechanisms, including the limitations of traditional try/catch blocks and the introduction of more sophisticated methods that not only enhance readability but also align with Kotlin's functional programming style, offering a more idiomatic approach to managing exceptions. And finally end with a philosophical discussion around error handling in Kotlin.

By the end of this session, you'll be equipped with advanced strategies for Kotlin's error handling that transcend conventional try/catch blocks, focusing on methods that not only enhance readability but also align with Kotlin's functional programming style. Additionally, the session will clarify best practices and the philosophy underpinning Kotlin's design, arming you with the necessary tools for effective error management.

How contributing to Redis OM Spring OSS helped me land a job at Redis

Back in 2022 I came across a book whose premisse is quite simple:

"Being the best at what you do is not enough, you must make your work visible."

By the same time, I had just attended my first conference and attended an amazing talk that truly inspired me to learn Redis. Couple months forward and I was contributing to Redis OSS, writing articles and making videos. Couple of years forward, I was hired by Redis. Proving the theory of the book.

In this talk, we'll go through one of the articles I wrote and show how I was able to apply a few of the key lessons from Kleon's book and discuss how we can apply them to our own creative journey, and maybe, land our dream jobs.

Count-Min Sketch: An efficient probabilistic Data Structure

A Count-Min Sketch is a data structure that estimates how often something appears in a large dataset while using very little memory. It relies on a table and hash functions to map items to specific spots in the table. Adding an item increases the values in those spots, and checking an item’s count returns the smallest value from them. While not exact due to possible collisions, it’s efficient and great for approximate counts when precision isn’t critical.

In this talk, we’ll explore:
• What this data structure is
• How it works internally
• How I used it to build an efficient version of Trending Topics for Bluesky

By the end of this session, you’ll have a clear understanding of Count-Min Sketches, why they’re valuable for handling large-scale data efficiently, and how you can apply them to solve real-world problems.

https://speakerdeck.com/raphaeldelio/count-min-sketch-an-efficient-probabilistic-data-structure