Spring I/O 2024

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/rweisleder/unit-test-your-java-architecture-with-archunit Repo: https://github.com/rweisleder/archunit-talk-examples Architecture and code are drifting more and more apart? The implementation of non-functional requirements and cross-cutting concerns is often forgotten? Too much spaghetti code due to circular dependencies? Sadly, such things happen far too often and will quickly lead to an unmaintainable code base. In the Java ecosystem, the library ArchUnit is a possible solution for this situation. We will look at how we can use ArchUnit to test our architecture within unit tests and finally get structure back into the system. We will also look at archunit-spring, which simplifies writing ArchUnit tests for Spring applications.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/introducing-spring-ai-springio24.pdf This session explores Spring AI, a new framework enabling Java developers to integrate AI seamlessly into enterprise applications. Spring AI was born from the realization that the AI/ML stack was becoming accessible to Java developers at large and no longer constrained to the traditional AI/ML community rooted mainly in the Python ecosystem. In this talk, the Spring AI project leads will introduce you to the main AI concepts you need to know and how to start writing AI applications quickly. Spring AI provides many components required in creating an AI software stack and brings Spring’s traditional design principles, such as portability and modular design, to promote POJOs as the building blocks of an AI application. This session will introduce many Spring AI features, starting with a portable client API to interact with AI models. You will learn how to create effective AI prompts, including using user-defined functions, and converting AI responses into POJOs. Use cases like “query over your docs” are demonstrated by showcasing Spring AI features such as creating Embeddings and storing them in a Vector Database. Also, Spring AI provides a lightweight ETL framework that takes your documents and stores them in the Vector Database. The popular RAG pattern and ways you can effectively evaluate how your AI application is performing are discussed.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/balkrishnarawool/continuations-the-magic-behind-virtual-threads-spring-io Repo: https://github.com/balkrishnarawool/continuations Have you wondered how virtual threads in Java are able to provide such high scalability? How is JVM able to switch between so many virtual threads while executing a single platform thread? If you did then this talk is for you. A Continuation is the magic that powers Virtual Threads. It can be viewed as a representation of the current state of the program or it can be viewed as a reference to the rest of the program. It helps us to pause execution of a program (or part thereof) and then resume it later. This ability to pause/resume is a powerful mechanism and is the basis for providing virtual threads. In this talk, we will start with explaining what continuations are and how does Continuation API in Java work. We will also explore the uses of continuations. And more importantly, we will write our own simple VirtualThread class using the Continuation API provided by JDK. This gives clear idea about the role of continuations in the nature of virtual threads.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/deki/serverless-java-with-spring Serverless computing revolutionizes how we build and run applications by abstracting server management, delivering fine granular auto-scaling, and billing only for execution time. This enables developers to focus on code, not infrastructure. Join this talk to understand how you can build and deploy cloud-native and Serverless Spring applications. You will learn how to run already existing Spring Boot applications in a Serverless environment with the AWS Serverless Java container and its integration with the Spring ecosystem. You will also learn how-to develop new event-driven applications with Spring Cloud Function. We will also cover support for GraalVM native images, developer tooling and additional performance optimizations.

Spring I/O 2024 - 30-31 May, Barcelona The endeavor to translate natural language queries into SQL has been a long-standing objective within the realm of computational linguistics and database management. Recent advancements in Generative Artificial Intelligence mark a pivotal moment in this journey. Current benchmarks have showcased that Large Language Models (LLMs) extend their utility beyond mere code generation to embrace specialized tasks such as Text-to-SQL conversion. This seminar aims to explore the cutting-edge developments in this field, highlighting effective methodologies based on frameworks that transcend the traditional tools and languages commonly associated with data science, like Spring Boot and the innovative “Spring AI” APIs, showing how these modern frameworks can facilitate equally the development of a bridge between natural language processing and database interaction.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/making-spring-cloud-gateway-your-perfect-api-gateway-solution-springio24.pdf Spring Cloud Gateway is a great piece of software, but it is still missing some additions and tunings to be the single API solution for an organization. In this session I’ll talk about various options to deploy it, and complete the missing parts: rate limiting, connection to SSO, Dynamic routing, Circuit breakers, auto documentation & testing and more.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/unlocking-javas-code-maze-springio24.pdf “Unlocking Java’s Code Maze” is not just a presentation. It’s an immersive experience designed to inspire and empower Java developers on their ongoing quest for mastery within the complex world of Java programming by providing practical insights for navigating the code maze effectively. Join Mihaela in this session and embark on a journey to unravel some of the secrets within the Java programming language through the lens of coding challenges. In this exploration, various types of coding challenges commonly encountered in Java development will be handled. You are encouraged to actively participate while we highlight lesser-known features, functionalities, and best practices within the Java language. These hands-on coding examples will showcase how different hidden gems can contribute to writing more efficient and elegant code.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://github.com/timosalm/magical-beans-and-mystery/blob/main/slides.pdf Repo: https://github.com/timosalm/magical-beans-and-mystery So you just created a Spring Boot project at start.spring.io, but then what? Don’t worry! Tiffany was just there too, and now we are here to help. Join us as we explore Spring at a beginner’s pace. Even though Spring makes Java development so much easier, the initial learning curve can feel daunting (there are over 20 years of resources after all!). Let’s break down what to look at first, and how to continue learning from there. We’ll start with the Spring Framework and its core building blocks, such as the IoC container and these magical beans. Next, we’ll dive into Spring Boot, an extension of the Spring Framework that simplifies and speeds up application development through autoconfiguration for various integrations and more. By the end of this talk, you will better understand Spring and how to create and run your own Spring applications.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/revving-up-the-good-old-samaritan-spring-boot-admin-springio24.pdf Delve into the potential of Spring Boot Admin and explore how ingeniously it can empower engineers to glean insights from their applications. Through Spring Boot Admin, we’ve not only pushed boundaries but also realized numerous success stories. In this discussion, I aim to dive into specific areas with live examples, shedding light on achievements, and insights gained & empowering the audience to experiment & hustle. - Application benchmarking with timeouts, TTLs, cache limits - Testing feature flags in a multi-channel, multi-tenant setup - Adjusting log levels on the fly, and debugging incidents has never been easy with the custom setup - Health checks and monitoring: Of course! - API-based access & controlling automation suites - Did I forget heap analysis & thread dumps, eh?

Spring I/O 2024 - 30-31 May, Barcelona Speakers: Marcos Maia / Lars Werkman Slides: https://2024.springio.net/slides/mind-the-gap-connecting-high-performance-systems-at-a-leading-crypto-exchange-springio24.pdf As one of Europe’s leading Crypto Exchanges, Bitvavo enables its ~2 million customers to buy, sell and store over 200 digital assets and provides a 24/7 service processing many thousands of transactions per second with stable sub millisecond execution times on its order flow. In this talk we will deep dive on the high level architecture of Bitvavo Exchange and discuss how we use Spring Boot to bridge the integration and monitoring of our systems with the ultra low latency Exchange and Matching Engine Systems. We will cover architectural patterns, lessons learned and good practices routing and processing high volumes of market data to Databases and Kafka while maintaining the high performance and scalability required from the leading Crypto Exchange in Europe.

Spring I/O 2024 - 30-31 May, Barcelona Building a service in production often resembles the daunting task of replacing an engine at 10,000 meters. How can we transition from Spring MVC to WebFlux or gRPC, or even allow them to coexist without outages? Should we keep additional servers until the migration is complete? Should we open an extra port? How do we manage the operational complexity involved? If you’ve ever pondered these questions, this talk might be for you. In this talk, we’ll delve into Armeria, an alternative open-source HTTP engine for Spring Boot, which can significantly streamline the migration process of your Spring Boot application. We’ll examine Armeria’s capabilities as an HTTP engine, RPC framework, and more, demonstrating how it addresses various migration scenarios involving a wide range of technologies, including Spring MVC, WebFlux, gRPC, GraphQL, and WebSocket. Whether you’re embarking on your microservices journey or looking to enhance existing Spring Boot applications, you’ll discover how Armeria can greatly simplify microservice architectures. Come discover how a touch of Armeria can make your Spring application bloom!

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/its-all-in-the-mix-producing-production-ready-apps-with-spring-boot-springio24.pdf Repo: https://github.com/jkuipers/in-the-mix-demos You already know how to develop Spring Boot applications: implement web controllers, work with databases, integrate security and so on. But just like releasing a song doesn’t end with recording the individual instruments, there’s more to getting an application production-ready than implementing functional requirements. In this tips & tricks talk Joris will explain various aspects of “mixing and mastering” your applications for release. He’ll cover configuring metrics, tuning container image layers, supporting HTTP response caching headers, securing actuator endpoints incl. masking of exposed secrets, integrating custom auto-configuration with Boot’s own and many other topics. If you want to become a bootiful producer as well, then don’t miss out on this demo-packed presentation and let your application become a nr. 1 hit!

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/jonatan_ivanov/2024-05-31-spring-io-micrometer-mastery-unleash-advanced-observability-in-your-jvm-apps Repo: https://github.com/jonatan-ivanov/teahouse/tree/2024-springio Is your application a black box? Is your current observability instrumentation not good enough? Do you want to add more to your metrics and distributed tracing? Join us and unlock the full potential of Micrometer and its cutting-edge observability features! Dive into: Micrometer Observation API: Instrument once and have multiple benefits out of it. Observation Conventions: Instrumentation with standardized naming and tagging. Automated Documentation: Effortlessly generate rich observability descriptions from your code. We’ll showcase: Practical code examples for instrumenting real-world applications. Advanced techniques to extract deeper insights and troubleshoot issues faster. Real-world use cases demonstrating the power of Micrometer’s observability toolkit. Ready to elevate your observability game using the industry’s golden standard? This talk is your one-stop shop for Micrometer mastery!

Spring I/O 2024 - 30-31 May, Barcelona Speaker: Nele Lea Uhlemann Slides: https://www.slideshare.net/slideshow/spring-i-o-deep-and-brief-dive-into-causality/269620850 How to bring causality to the forefront in Spring services and systems? When building and running complex systems, we encounter multiple options, and various tools address causality concerning service-to-service invocation. Traces, Workflows and Service Meshes provide insights into causal relationships. They make dependencies between different services, events, and transactions visible. Let’s dive into the technical choices available to make causality visible in our systems and see how they integrate with Spring services. The session includes examples of Dapr workflows, displaying collected traces in Jaeger, Istio’s call graphs with Kiali. We delve into the purpose of causality in each tool, discussing their differences and similarities. Discovering how operators and application engineers perceive causal relationships differently is not just insightful—it’s a key factor that drives better collaboration and communication among engineering teams. This, in turn, leads to more effective system design, debugging, and troubleshooting.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/beyond-built-in-advanced-testing-techniques-for-spring-boot-applications-springio24.pdf Repo: https://github.com/mvitz/beyond-spring-boot-testing Spring Boot ships with testing batteries included, and you know that. But what happens when you reach the end of all this? You will need to find additional libraries or come up with your solutions for extending the built-in capabilities. This session will provide you with exactly that. Libraries and custom-built extensions in combination with the great test support of Spring that I used to ease testing and solve challenges within my projects.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/raphaeldelio/asyncapi-and-srpingwolf Repo: https://github.com/raphaeldelio/springwolf-demo-spring-io-2024 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.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://github.com/rstoyanchev/spring-graphql-activity/blob/main/GraphQL-Java-and-Spring-The-Latest-Features.pdf Repo: https://github.com/rstoyanchev/spring-graphql-activity Spring for GraphQL 1.3 releases in May, 2024, just days before the Spring I/O conference, and less than a month after GraphQL Java 22. There are plenty of new features and themes to digest on both sides. From GraphQL Java, expect support for incremental delivery with defer and stream directives, oneOf input types where exactly one field is set and others are omitted, request execution insight, schema diffing, and more. From Spring for GraphQL, expect the GraphQlClient revisited for blocking vs non-blocking execution, new SSE transports based on the GraphQL over HTTP RFC, EntityMapping controller methods for federated schema types, integration with DGS code generation, and more. In addition, the Spring and DGS teams have collaborated on a common foundation for both projects. This talk will shed light on the latest developments to help you make sense and understand how to use them to make your applications better.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/thombergs/platform-engineering-with-spring-boot In a company with tens or even hundreds of developers, there is a need to align engineering practices to reduce the sprawl of complexity. Platform engineering aims to provide tools and practices so that each team doesn’t have to reinvent the wheel. In the Java world, Spring Boot offers a widely adopted programming model and brings many features and integrations out-of-the-box. It also provides an extensible platform to build upon. In this talk, we will dive into many of Spring Boot’s extensibility mechanisms to build shared libraries that integrate with whatever platform you’re running your applications on so that the product teams can focus on generating value for the customers instead of building their own integrations. Along the way, we will steal a glance at features of the Java platform at Atlassian.

Spring I/O 2024 - 30-31 May, Barcelona Speaker: Laurentiu Marinescu Slides: https://2024.springio.net/slides/unveiling-the-path-to-spring-boot-3-at-the-most-important-tech-company-youve-never-heard-of-springio24.pptx Let’s discover together the journey to migrate from Spring Boot 2.x to Spring Boot 3 in an environment where highly intensive processes depend on your platform. Of course, we want our services to run on latest tech available, but what are the steps to get there, considering your current applications technology stack. In this talk, I’ll take you through the challenges encountered during the migration which required meticulous planning and smaller milestones to realize it. What makes it distinctive? Seamless rolling upgrades from version X to version Y within a fully air gapped setup where full automation and high availability are vital. I will provide you hints and tips we have applied to leverage the latest features of Spring boot 3. If you want to know more about ASML😊 or you are dealing with Spring/Spring Boot upgrades for your system in a large organization, then this talk is definitely for you.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/the-good-the-bad-the-native-springio24.pdf Native image from GraalVM offers a good, wonderful way to optimize our application, written for the JVM, and transform it in a native executable that will guarantee low startup times, low resources consumption, high performances. A lot of libraries and frameworks are still not ready for this, and that’s bad! Come discover my personal journey in the native compilation of a JVM-based application. We will see the good things, as well as the pains, the struggles and some of the ways I’ve found to be effective to solve difficult moments.

Spring I/O 2024 - 30-31 May, Barcelona Speaker: Maksym Telepchuk Modular libraries that leverage Spring Cloud AWS for more than 120 teams and 420 production applications make their integration with AWS and company-specific integrations easier. Spring Cloud AWS provides a convenient way to interact with AWS using well-known Spring idioms and API. Our libraries help integrate company-specific extensions on top of it in a seamless way. Centralised upgrades and customisation mechanisms of Spring Cloud AWS at such a large scale benefit our users and also bring exciting challenges for us, the engineering team that manages these processes. In this session, we will cover some important aspects that you will find useful in similar circumstances: Why use Spring Cloud AWS; Improvements that the latest version of Spring Cloud AWS (v3) brings along; Extending the Spring Cloud AWS and customisation with own domain-specific integrations; Handling an upgrade for a large number of teams and applications with the processes of discovery, design, and release model; Challenges that we have met, how we overcame them, and what conclusions were drawn.

Spring I/O 2024 - 30-31 May, Barcelona As Java developers, we know the benefits of type-safety when building apps. The problem? Usually, that type-safety ends when we leave the server. What if it didn’t have to be that way? In this presentation, you’ll learn how to build a full-stack reactive web app through live code examples. We’ll use Spring Boot and Java on the backend and React with TypeScript on the frontend, connecting the two with the new Hilla framework from Vaadin.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/thomasvitale/concerto-for-java-and-ai-building-production-ready-llm-applications Repo: https://github.com/ThomasVitale/concerto-for-java-and-ai Spring AI Examples: https://github.com/ThomasVitale/llm-apps-java-spring-ai Imagine you’re a music composer struggling to find inspiration for a pivotal movie scene. Then, you remember you’re also a software engineer, and the solution becomes suddenly obvious. Join me in this session, where I’ll demonstrate how I enhanced my music composition process by harnessing the power of Spring Boot and AI. This presentation will discuss the core architectural patterns for introducing AI capabilities into an existing software system, exploring concepts like templated prompts, agent tools, and integration of external knowledge. The Java ecosystem is getting more and more capabilities for building AI applications. But are they ready for production? Are there any gaps? Throughout the session, I’ll build a “composer assistant” application using Spring Boot and an AI Orchestrator (LangChain4J, Spring AI) to showcase how to make an LLM application production-ready. Is the developer experience affected when working locally with language models? How is observability different when it comes to tokens? Can we ensure resilience across the many integrations orchestrated by the AI? What strategies are available for deploying LLM applications? In a final twist, you’ll choose which movie scene to score, and I’ll compose and perform the music live for it, supported by AI. Will it meet the mark? There’s only one way to find out: join me in exploring the practical side of AI applications, where Java and Generative AI offer tangible solutions to real-world use cases. Aaaaand action!

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/olgamaciaszek/o-2024 Repo: https://github.com/OlgaMaciaszek/interface-clients-spring-io-2024-demo Spring now allows you to easily create elegant, highly readable, interface-based HTTP and RSocket clients. In this session we will discuss how developers can best use the clients in their applications to make HTTP and RSocket communication seamless. During the presentation, we will go over various popular use-cases, but we will also discuss more complex scenarios, including how to best handle errors, override preset elements in individual requests, work with URIs, or pass attributes to underlying filter functions. We will show how to set up Spring Interface Clients with different underlying HTTP clients and how to easily integrate them with Spring Cloud LoadBalancer. Last but not least, we will take a peek into auto-configurations for Interface Clients.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/a-spring-developers-guide-to-navigating-the-frontend-landscape-springio24.pdf This is a beginner-friendly session designed for Spring developers who are trying to navigate the landscape of frontend development. When you need to develop a new frontend for your Spring application, what approach do you take? Do you leverage your existing Java skills and create it using a Java framework? Or do you opt for a modern JavaScript framework like React, Angular, or Vue? Different requirements may call for various solutions. In this session, we will explore a wide range of solutions from Java Frameworks to Template Engines, HTMX, JavaScript Frameworks and more. By the end of this talk, you will be up to date with the latest techniques for building frontend applications with Java and Spring.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/secure-test-repeat-a-guide-to-spring-security-integration-testing-springio24.pdf In this talk, I’ll dive into the essential aspects of integration testing within the Spring Security framework. I will share practical strategies and advanced techniques to effectively test security features in Spring applications, ensuring their robustness and reliability. This session is designed for developers and testers who want to deepen their understanding of Spring Security. I’ll blend theoretical knowledge with real-world examples to enhance the security and quality of your software projects. Whether you’re just starting with Spring Security or looking to refine your skills, my talk will provide valuable insights and best practices for integration testing in this crucial area of cybersecurity.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://1drv.ms/p/s!AqMtqX6qs5wlrb1TxNo7yTSynqDWEQ Repos: https://aka.ms/fitness-store - https://aka.ms/spring-azure-fun Come see the ultimate way to combine Spring and Azure to make coding a blast! They are both amazing on their own. Put them together and you get developers who are over the moon, making cool apps that people love. However, navigating the vastness of Spring and Azure can be daunting. Learning them can be tough. Our talk is like a fast-forward button. We will show you the fastest ways to combine Spring and Azure. This means your coding is quick, your tests are smooth, your apps can grow and be intelligent (AI), and your design is solid. You will watch quick demos that highlight the top tricks for using Spring with Azure. And you will not leave empty-handed — you will get a git repo with the best Spring plus Azure setups, straight from the experts.

Spring I/O 2024 - 30-31 May, Barcelona IntelliJ IDEA is packed with useful features that enhance developer productivity and simplify working with the code. This session takes you through the cool features of IntelliJ IDEA: refactorings, shortcuts, fast navigation, code completion kung-fu, live templates, structured search, dependency matrix, and other productivity tips and tricks that the IDE provides. You will learn what the IDE offers for Spring developers, including language injection, database support, actuator integration, and project health monitoring with Qodana.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/christophstrobl/spring-data-cookbook No matter if you have just discovered your passion for cooking or are already an advanced chef, in this session we discover ways to bake applications that deliver everything from persistence to web using your favorite ingredients. Let us explore classic data repository recipes and introduce fresh compositions leveraging latest Spring functionality along with JPA and a touch of NoSQL, mixing in result limits and keyset scrolling, rounding things off with an icing made of observability & metrics.

Spring I/O 2024 - 30-31 May, Barcelona In the last decade, much emphasis has been placed on decomposing monoliths into microservices. While this practice has important benefits, including increased agility for development teams and independent lifecycle management for applications, it also introduces new complexities, such as managing many git repositories and many component deployments. In some cases, the benefits of monolith decomposition are absolutely necessary, but not in all. Sometimes we invite complexity for no good reason. In these cases, it behooves us to consider maintaining monolithic code bases. This does not mean, however, to revert back to the spaghetti monoliths of yesteryear, or to the cursory attempt to organize code into services of the SOA age. Instead, we must be sure to apply the hard-fought lessons from microservices and create a new paradigm for Modern Monoliths. Enter Spring Modulith. In this talk, we will explore the concept of the modern modular monolith and how this compares to the monoliths of yore. How are they different, and what challenges do these differences aim to resolve? By the end of this talk you will understand when and how to apply the principles of modular architecture to your Spring Boot applications using Spring Modulith.

Spring I/O 2024 - 30-31 May, Barcelona Imagine deploying microservices to low-powered, distributed devices at the network edge. This talk dives into building and deploying cloud-native, kubernetes-native, enterprise-grade, production-ready applications, to the edge, with Spring Boot. WHAT YOU’LL LEARN: Harnessing the power of Spring Boot and GraalVM: Discover how AOT processing with GraalVM can significantly improve startup time and memory footprint, making Spring Boot ideal for resource-constrained edge devices. Kubernetes at the edge: Explore the possibilities of deploying microservices to a lightweight Kubernetes cluster, unlocking scalability and resilience. Scaling on demand: Learn about techniques for scaling to zero and auto-scaling, ensuring optimal performance at the edge. Conquering the edge: Get practical tips for handling unreliable internet connections and other challenges specific to edge deployments. JOIN THIS SESSION TO: Gain valuable insights into the potential of Spring Boot and GraalVM for edge computing. Unleash the power of Kubernetes on resource-constrained devices. Discover robust patterns for building cloud-native applications tailored for the edge. Leave inspired to explore innovative possibilities for your next Spring Boot project. BONUS: Witness a live demo showcasing the reference architecture in action, running on a Raspberry Pi. Get valuable resources and learning materials to continue your edge exploration.

Spring I/O 2024 - 30-31 May, Barcelona Speakers: Dan Dobrin / Abdel Sghiouar Slides: https://2024.springio.net/slides/the-future-of-java-performance-in-serverless-native-java-crac-and-project-leyden-springio24.pdf Repo: https://github.com/GoogleCloudPlatform/serverless-production-readiness-java-gcp/tree/main/services/quotes Applications typically run better on serverless platforms if they start fast, with instant peak performance and lower CPU/memory consumption. You’ll save on costs if the application needs less time and resources to run on, handle more requests with less CPU/memory and achieve better performance. We love to use Java for its stability, performance and portability, however we all know that Java and its various web frameworks aren’t known for starting fast or not using a lot of resources. Don’t worry, I’ll start exploring carefully how this all changes with three technologies geared towards improving Java app runtime efficiency in serverless environments. - Native Java Images, with GraalVM - JVM Checkpoint and Restore, with CRaC - Upcoming OpenJDK runtime efficiency project, Project Leyden

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/wimcreuwels/fun-with-feature-flags. Repos: https://github.com/LewisMcReu/FFF_Unleash_backend https://github.com/LewisMcReu/FFF_Unleash_frontend https://github.com/LewisMcReu/FFF_Togglz_backend https://github.com/LewisMcReu/FFF_Togglz_frontend A dive into the possibilities of feature flags in Spring. The feature flag/toggle is a simple concept that I have nonetheless rarely seen in Spring applications. I took it upon myself to learn more about the plentiful libraries out there and will share my experiences in trying them out. A broad overview of the contents: - what are feature flags/toggles and why do we use them? - multiple libraries to facilitate feature flags - live reloading of the Spring Context to apply config changes - demos of all topics

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://www.slideshare.net/slideshow/cracking-the-code-review-at-springio-2024/269479679 Code reviews are vital for ensuring good code quality and fostering teamwork. They serve as one of our last lines of defense against bugs and subpar code reaching production. Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standard practices. How can we improve this crucial process? From a decade’s worth of experience and consulting across varied companies, I’ve extracted essential lessons about code reviews. In this session we will cover: The Art of Effective Code Reviews: Learn “how not to come across as a passive-aggressive jerk”, the value of self-reviews, and effective communication strategies. Streamlining the Review Process: Embrace clear repository ownership and refined review guidelines for more efficient and constructive reviews. Elevating Reviews with Automated Tools: The most fun part! Explore tools that reinforce code consistency and quality, from automated style fixes to architecture checks. Let’s cut through the noise of bikeshedding and focus on the essence of the changes.

Spring I/O 2024 - 30-31 May, Barcelona Save the date for Spring I/O 2025: 21-23 May

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://asm0dey.github.io/kotlin-spring-springio/1 As a seasoned developer, you’re likely already familiar with Spring. But Kotlin can take your developer experience with Spring to the next level! Join this webinar and learn how to: - Add new functionality to existing classes with Kotlin extension functions. - Use Kotlin bean definition DSL. - Better configure your application using lateinit. - Use sequences and default argument values to write more expressive code. By the end of this talk, you’ll have a deeper understanding of the advanced Kotlin techniques that are available to you as a Spring developer and be able to use them effectively in your projects.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/maciejwalkowiak/implementing-domain-driven-design-with-spring Repo: https://github.com/maciejwalkowiak/implementing-ddd-with-spring-talk After years of Microservices hype, it seems that our industry now understands its costs and how difficult it is to build a distributed system. We are looking again towards building monolithic applications. But how can we develop monoliths that don’t turn into an unmaintainable mess? There is no single recipe, but we can say with a high degree of confidence that domain modeling techniques presented in Domain-Driven Design, in combination with Clean/Onion/Hexagonal Architecture, can significantly help in achieving clear and well-structured code aligned with the business needs. In this talk, we will focus on the implementation aspects of DDD. You will understand what Aggregates, Value Objects, Repositories, Domain Events are, and how to implement them with Spring and other technologies from the Spring ecosystem. You will learn how to structure application services with Use Cases and how to leverage dependency inversion to separate technology-specific implementation details from the application and domain code.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/efficient-containers-with-spring-boot-3-java-21-and-cds-springio24.pdf Repo: https://github.com/sdeleuze/petclinic-efficient-container/ Spring Boot 3 brings runtime efficiency and performance related enhancements in order to optimize and reduce the cost of the hosting of your Spring Boot applications deployed as containers on production. In this presentation, Sébastien will share an overview on how to migrate Spring Boot 2 applications running on Java 8 to Spring Boot 3 running on Java 21, and how to leverage builtin support for technologies like Virtual Threads, Spring Ahead-Of-Time optimisations, CDS and Buildpacks to run them faster and more efficiently on the JVM. Sébastien will also share related data points and provide a glimpse into the future by demonstrating how Project Leyden should allow to speedup even more the startup and warmup of your Spring Boot applications.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/event-driven-autoscaling-for-serverless-java-springio24.pdf Kubernetes makes it possible to autoscale various business use cases from web apps to mobile, IoT edge streaming, and AI/ML in more reliable and stable ways. One caveat of Kubernetes autoscaling is based on hardware resource utilization (CPU, memory) through Horizontal Pod Autoscaling. This causes a new challenge to build an event-driven serverless Java on Kubernetes because the event metrics from multiple event sources (e.g., Apache Kafka, AWS SQS) are more relevant than a pod’s CPU usage for deciding when applications need to be scaled out and in. Fortunately, KEDA and Knative on Kubernetes are designed to solve this challenge by autoscaling both standard apps and serverless by event metrics in a separate way. This session will teach you how to redesign your Kubernetes autoscaling architecture by event-driven metrics from Apache Kafka over standard resources (CPU, Memory) with Knative and KEDA integration for serverless Java.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/deepu105/a-passwordless-future-passkeys-for-spring-developers Weak passwords remain one of the major causes of breaches and security incidents. The Web Authentication standard provides a robust framework for passwordless authentication using passkeys. Passkeys are the latest revolution in authentication. You may have used it with Google or GitHub. But what exactly is it and how does it work? You will learn all about it in this talk. We will dive into the core concepts of passkeys, their architecture, and their pros and cons. We will see how Passkey leverages public key cryptography and biometrics/hardware authenticators to offer enhanced security and usability while eliminating the vulnerabilities associated with traditional password-based systems. We will explore how Java developers can leverage WebAuthn Java libraries to implement passkeys in their apps. We will also learn to use passkeys with Spring Security and external Identity providers. There will be demos, showing step-by-step integration of passkeys into Java web applications.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://prezi.com/view/SUQH8Oz4YKDbJrzD295h/ Do you also dream about the 4-hour workweek? Ever wanted to go to Spring I/O without having to ask your boss for permission? In this talk, I’ll share my personal story: the story behind JobRunr, an open-source distributed job scheduler that now pays my bills! I’ll explain why it makes sense to learn different programming languages, I’ll tell you all about the highs and the lows I encountered during the development of JobRunr, I’ll show you how open-source can be a marketing bliss and I’ll enlighten you with my plans for the future. After this session, you will know whether being a full-time open-source developer is something for you, how you can find product market fit and how you can also become your own boss!

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/spring-framework-62-core-container-revisited-springio24.pdf In the Spring team, we take the opportunity to wrap up long-standing core container concerns in Spring Framework 6.2: component model variations, autowiring performance, locking behavior, as well as our lifecycle management revision. In this session, we will discuss some of the strategic fine-tuning in the core container: the motivation, the tradeoffs, and the impact.

Spring I/O 2024 - 30-31 May, Barcelona Slides & repo: https://github.com/patbaumgartner/talk-lean-spring-boot-applications-for-the-cloud With the starters, Spring-Boot offers a functionality that allows you to set up a new software project with little effort and start programming right away. You don’t have to worry about the dependencies, since the “right” ones are already preconfigured. But how can you, for example, optimize the start-up times and reduce the memory footprint and thus better prepare the application for the cloud? In this talk, we will go into Spring-Boot features like Spring AOT, classpath exclusions, lazy spring beans, actuator, and more. In addition, we’re also looking at switching to a different JVM and other tools. All state-of-the-art technology, of course. Let’s make Spring Boot great again!

Spring I/O 2024 - 30-31 May, Barcelona Speaker: Rafael Ponte Slides: https://speakerdeck.com/rponte/distributed-scheduling-with-spring-boot-the-challenges-and-pitfalls-of-implementing-a-background-job Sooner or later a developer will implement his/her first background job using Java and Spring Boot, and what usually is a simple task for the majority of systems might become a nightmare in scenarios that need to deal with high performance, parallelism, distributed systems and a large volume of data. Scenarios like those hide several issues which many developers are not used to, such as large volumes of data, network failures, data inconsistency, out-of-memory errors and even taking the whole system down. Although it seems controversial, dealing with many of these problems does not require hype technologies or services, but solid distributed systems fundamentals. This talk will present how an experienced developer implements a background job with Java and Spring Boot taking into consideration the main challenges and pitfalls it brings along, and how he/she designs a solution for high-performance, resilience and horizontal scalability at the same time he/she takes advantage of many modules of Spring Boot, Hibernate and the relational database. If you still believe that a background job is a simple task, so this talk is for you!

Spring I/O 2024 - 30-31 May, Barcelona Spring Boot 3.x and Java 21 are here, and there’s never been a better time to be a Java developer! In this talk we’ll look at the incredible opportunities that lay ahead for the Spring Boot developer, and especially those using Java 21 and later. Spring Boot continues to offer the most sophisticated and robust ecosystem of integrations - supporting AI, GraphQL, easy data access, security (hello, Spring Authorization Server!), and so much more. And, it offers cutting edge support for production-centric optimizations like Project Loom’s virtual threads, Project CRaC, and GraalVM. Join me Spring Developer Advocate Josh Long (@starbuxman) and we’ll explore next-gen Spring together.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://www.slideshare.net/slideshow/automated-software-refactoring-with-openrewrite-and-generative-ai-pptx-pdf/269542855 The software industrial revolution has arrived. Software is now 80% open source and third-party and 20% proprietary code that stitches it together into business-critical applications. In these large and diversely composed codebases, dependencies change frequently at their own pace and security vulnerabilities can be introduced at any time by anyone. Not updating software regularly leads to critical bugs, performance, and security issues (plus your code can just get harder to work with!). Mass code refactoring in these massive codebases is a multi-point operation that requires accuracy and consistency. It’s about affecting change across many individual cursor positions in thousands of repositories representing tens or hundreds of millions of lines of code. Whether you’re migrating frameworks or guarding against vulnerabilities, this requires coordination, tracking, and accuracy. This is not a problem AI can solve alone. AI, like many humans, is not good at math and programming. AI needs a computer just like a human does. In this talk, we’ll discuss automated code remediation with the deterministic OpenRewrite refactoring engine, a technology born at Netflix in 2016. It’s built on manipulating the Lossless Semantic Tree (LST) representation of code with recipes (programs) that result in 100% accurate style-preserving code transformations. It is a rule-based, authoritative system. Then we’ll show how to couple the precision of a rules-based system with the power of AI. We’ll demonstrate a generative AI procedure that samples source code to identify defects and uses OpenRewrite to fix them. This is a general purpose pattern you’re going to start seeing a lot of — “ChatGPT gets a computer” (with OpenRewrite as the computer in this case).

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/build-faster-persistence-layers-with-spring-data-jpa-3-springio24.pdf Over the years, Spring Data JPA has become the de facto standard for persisting data in a relational database. It provides excellent developer productivity and is so easy to use that you can learn it within a few hours. And Spring Data JPA 3 improves all of that even further. But handling vast amounts of data or guaranteeing very short response times still causes many problems. Features and concepts that work perfectly fine for smaller applications start to slow down your application. The good news is that you can easily avoid all of this. Spring Data JPA is a great fit for complex projects with high-performance requirements. You only need to know which features to use and which to avoid. During this talk, I’ll show you how to get the most out of your persistence layer and which new features in Spring Data JPA 3 help you improve your application’s performance even further.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://www.slideshare.net/slideshow/going-aot-with-graalvm-for-spring-boot-spring-io/269499148 Repo: https://github.com/alina-yur In the past few years GraalVM got widely adopted by the Java ecosystem, and even more more since Native Image becoming officially supported since Spring Boot 3.0. Now it’s hard to imagine starting a new project, especially for the cloud, without at least considering going native. However, taking a new technology to production requires research and preparation. What is the best way to build and deploy such native executables? Once deployed, how can I monitor them? Can I test them as I do with regular Java applications? What if startup is less important, how do I optimize for peak performance and latency? How do I use 3rd-party libraries? In this session, we’ll go through all those aspects and illustrate them with demos.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://docs.google.com/presentation/d/1Suna1vSiQVhH4tc-wwoAKu2iX5OuXBqXc3ZMm0DGp78/edit?usp=sharing Repo: https://github.com/spember/spring-bikeshed Event Sourcing is a modern but non-trivial data model for building scalable and powerful systems. Instead of mapping a single Entity to a single row in a datastore, in an Event Sourced system we persist all changes for an Entity in an append-only journal. This design provides a wealth of benefits: a built-in Audit Trail, Time-Based reporting, powerful Error Recovery, and more. It creates flexible, scalable systems and can easily evolve to meet changing organizational demands. That is, once you have some experience with it. Event Sourcing is straightforward in concept, but it does bring additional complexity and a learning curve that can be intimidating. People coming from traditional ORM systems often wonder: how does one model relations between Entities? How is Optimistic Locking handled? What about datastore constraints? Based on over eight years of experience with building ES systems in Spring applications, we will demonstrate the basics of Event Sourcing and some of the common patterns. We will see how simple it can be to model events with available tools like Spring Data JPA, JOOQ, and the integration between Spring and Axon. We’ll walk through sample code in an application that demonstrates many of these techniques. However, it’s also not strictly about the code; we’ll see how a process called Event Modeling can be a powerful design tool to align Subject Matter Experts, Product, and Engineering. Attendees will leave with an understanding of the basic Event Sourcing patterns, and hopefully a desire to start creating their own Journals.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/migrating-from-spring-data-jpa-to-spring-data-jdbc-springio24.pdf A long long time ago in a city far away Jens Schauder started coding on a desktop calculator programmable in assembly. Over 30 years later, after almost 20 years as a consultant working mostly with huge enterprises, he joined the Spring Data Team. Here he works mainly on the “JPA” and “JDBC” modules and tells about it at conferences or helps other developers on StackOverflow. In his spare time he spends time running, bouldering, playing games, torturing himself with Freeletics. And eventually he will write a book about Spring Data JDBC.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/spring-boot-and-kotlin-pain-or-gain-springio24.pdf Spring Boot has been the No. 1 framework for Java developers ever since. With its first-class support for Kotlin, a new frontier of possibilities opens up. Can Kotlin propel Spring Boot to new heights of efficiency and simplicity beyond what Java offers? Join me on an enlightening journey as we explore the potential advantages and pitfalls of integrating Kotlin into the Spring Boot ecosystem. We’ll begin by dissecting Spring Boot’s support for Kotlin features such as extensions, data classes, nullability, and more. Can they live up to their promise of improved code safety, conciseness, and readability compared to their Java counterparts? In the second part, we will venture into more advanced territory by investigating how reactive Spring Boot Webflux - highly efficient yet notorious for its complexity and steep learning curve - might be simplified using Coroutines, Kotlin’s built-in asynchronous language feature. Are the potential benefits worth the hassle of learning Coroutines? And yes, we’ll take a look at the role Virtual Threads can play in that regard! Finally, we’ll dive into the practical realm, transforming a Spring Boot application written in Java to Kotlin on the spot using live coding to explore tooling support and possible conversion strategies, accompanied by intriguing stories from real-world use cases. At the end of the journey, you have gained a nuanced understanding of the benefits and drawbacks Spring Boot offers when used with Kotlin compared to Java. Will the pain of adoption be worth the potential gain? Let’s find out together!

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://2024.springio.net/slides/debug-your-native-spring-springio24.pdf GraalVM Native Image can be used to turn your Spring Boot 3 service into a standalone platform executable. Such executables provide valuable performance benefits in production, and the process of creating them is now supported as a standard procedure by major application frameworks. Nevertheless, there are several quirks. Some of them appear at build time (like the build time itself). Some appear at run time. Take debugging, for example. Regular JVM debuggers work using the JDWP protocol. However, native programs require native platform debuggers, and certain support should be added to Native Image. BellSoft recently implemented such debugging support for macOS, so we’ll analyze how it works with different operating systems and tools.

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/ivargrimstad/why-spring-matters-to-jakarta-ee-and-vice-versa-eba1b242-2d02-4021-8741-7feaa42beff1 Jakarta EE 9 changed its package namespace from javax.* to jakarta.*. This may sound like a trivial change that mostly affects Jakarta EE. So, why should Spring developers care? As it turned out, the namespace changes rippled throughout the entire Java ecosystem and Spring was no exception since it incorporates and builds on a lot of the Jakarta EE APIs and technologies. This means that it is a great advantage for a Spring developer to be aware of what is going on with the Jakarta EE specifications. Looking at it from the other way around, Jakarta EE benefits a lot from looking at what Spring Framework does. The Jakarta EE specifications can pick up and standardize technologies and practices that have been made industry standard by Spring Framework. Jakarta Data is an example of this. Come to this session to learn why Spring matters to Jakarta EE as well as how Jakarta EE matters to Spring!

Spring I/O 2024 - 30-31 May, Barcelona Slides: https://speakerdeck.com/bnasslahsen/openapi-3-dot-1-and-spring-boot-3-whats-new Repo: https://github.com/springdoc/springdoc-openapi-demos APIs play a central role in the evolution of business IT. Adopting an industrial approach is crucial. In this discussion, we will extensively explore springdoc-openapi. With over 25 million monthly downloads, springdoc-openapi is a significant player in the OpenAPI landscape for spring applications. We will delve into how this project can expedite the adoption of APIs. During this talk, we will deep dive into springdoc-openapi main functionalities: - Introduction to OpenAPI 3 - What is the purpose of springdoc-openapi? - Integration with spring-web and spring-webflux - GraalVM native images support - Integration with Kotlin - Integration with actuator - Reuse Javadoc in REST APIs descritpion - Integration with spring HATEOAS and spring Data REST - Integration with spring-security and OAuth 2.0 - Example with spring–authorization-server - Multiple OpenAPI groups support - Integration with spring-cloud-function-web - Integration with spring-cloud-gateway in a microservices architecture - Integration with Kotlin / Groovy - Generation of the OpenAPI 3 documentation with gradle/maven

Spring I/O 2024 - 30-31 May, Barcelona Repo: https://github.com/bclozel/ops-status/ If you’re maintaining an existing web application, upgrading to the latest Spring version is not just about maintenance: it’s also an opportunity to hit that “refresh” button on your web stack and bring meaningful improvements to your developer experience and new value to your users. With the latest Spring Boot 3.2 version, the Spring team brings new possibilities to keep your app relevant and your development team happy, empowering you to carefully evolve your application: Improve the runtime efficiency with Virtual Threads Use a modern HTTP client API without learning reactive with the new RestClient Leverage metrics and traces during production incidents Manage and rotate TLS certificates with bundles and reloading Connect to external systems with Docker compose and Testcontainers Get startup time improvements with AppCDS or Checkpoint Restore

Spring I/O 2024 - 30-31 May, Barcelona Speaker: Alex Soto Slides: https://docs.google.com/presentation/d/1iCUCJhYTS2WFBgF3mGKbZMzx0r6lJhWx1ZE5OodyaXw/edit?usp=sharing Backstage is a powerful and open-source developer portal framework developed, offering a centralized platform for developers to access a wealth of tools, services, and knowledge, streamlining development workflows and enhancing productivity. Improve developer’s performance by creating golden paths with pre-architected stack to building and deploying a particular piece of software. By attending this session, you will gain insights into creating a developer-centric environment through the Backstage Internal Developer Portal while harnessing the capabilities of Java. Whether you are a developer, DevOps engineer, or a tech leader, this session promises to equip you with the knowledge and tools necessary to unlock the full potential of your development team.

Spring I/O 2024 - 30-31 May, Barcelona Speakers: Mauricio Salatino / Thomas Vitale Slides & Repo: https://www.salaboy.com/2024/06/03/spring-i-o-dapr-and-spring-boot/ Imagine you are tasked to build the most straightforward application in a distributed system. How will your application consume external services? Which strategy will you use to ensure resilient interactions with other applications in the system? Will data consistency be guaranteed even when transactions cross application boundaries? Are you making your developer experience worse by dealing with all the complexity? We’ve all been there. This session will demonstrate the combined power of Dapr and Spring Boot for handling the most common distributed application challenges. Dapr is an open-source, cloud-native project designed to decouple application concerns from the underlying infrastructure through convenient APIs, enabling developers to consume several capabilities without extra cognitive load. Through live coding and hands-on demonstrations, Thomas and Mauricio will show how Dapr integrates with Spring Boot and helps you focus on writing the business logic rather than creating new solutions for recurring cloud-native patterns. Developer experience will be paramount. It’s a promise: no YAML and no Kubernetes will be needed to develop your applications! Here’s the catch: once you’re done, your applications will run across different environments and configurations (such as Kubernetes or a cloud platform). They will integrate with other services in the system without any code change. Will we reach the goal? Join us and find out!

Spring I/O 2024 - Barcelona, 30-31 May Slides: https://2024.springio.net/slides/spring-security-architecture-principles-springio24.pdf Repo: https://github.com/Kehrlann/spring-security-the-good-parts When you need to secure your application, you use Spring Security. It’s the de-facto standard, it’s robust, extensible, and brings sensible defaults to your application. But newcomers can feel lost as soon as they step out of the “Getting Started” guides and need to fine-tune the configuration to their specific use-cases. Developers can find themselves frantically copy-pasting from Stack Overflow until it kinda-sorta works. Spring Security only uses a handful of core building blocks, and they are present everywhere in the library. Knowing what those are, how they are meant to be used, and how to effectively leverage them will give you the keys you need to implement all your custom needs. This session aims to provide a useful method for understanding Spring Security’s architecture, and how to customize it. Through some theory (diagrams!) and practice (live coding!), you will get familiar with the general architecture, foundational patterns and common abstractions. No more foraging StackOverflow in despair!

Spring I/O 2024 - 30-31 May, Barcelona Java was once a language that dragged along at snail’s pace. Thankfully, that’s no longer the case. In the recent years the pace of development has accelerated, both in language features and in the JDK improvements. Come along to dive into some of the recent changes of Java that are both fun and powerful to use, to learn how you can benefit from these, and we’ll also discuss where the language is heading in the near future.

Spring I/O 2024 - 30-31May, Barcelona