Program

Adele Carpenter

---

Have you ever wondered what a teacher, pilot or economist could teach you about software delivery?

As technology leaders, we often lean on heuristics and truths that we collect throughout our career. For example: start small and scale up later, iterate and ship often, good enough is good enough. These are actually pretty powerful insights that can be applied in other areas and not just in software development projects.

What if we flip the script? What if we look at other disciplines, like teaching, personal training, economics and aviation? What do people in these industries and professions just “know”? And can we apply it to our roles as Project Managers, Developers and Tech Leads?

This is an exciting question, because delivering the right thing at the right time for the right cost requires a lot more than just technical skills. It also requires an understanding of the behaviours and contextual factors that can drive success of the project. This intuition and understanding can take years to develop. We’re going to do it in an hour.

So if you’ve ever asked yourself or your team questions like:
- Should we continue along this course of action or pivot and try something else?
- How can we better evaluate our alternatives?
- How can we facilitate a continuous improvement culture in the team?
- How can we deal with unforeseen events in a more methodical way?

Then you are going to get a lot out of this talk.

I’ll be using my experiences as an economics major, powerlifter and aviation enthusiast to lead you to the necessary “ah ha” moments years ahead of schedule.

Close

Martin Hertz

---

Advocating for technical improvements to a product or system can be extremely challenging. In this session, you’ll learn how to better champion technical initiatives. We’ll talk about how the concept of “technical debt” is, counterintuitively, holding you back.

The metaphor of technical debt has had a hugely positive impact on software development. However, its convoluted current state is hindering decision-making and value creation. The technical debt metaphor deserves its exalted place in history, but it’s time to move beyond it.
We’ll investigate the origins of the technical debt metaphor and discuss how current approaches driven by it are hampering technical efforts. We’ll use this understanding to identify more inclusive approaches to cross-disciplinary prioritization. You’ll be prepared to better collaborate with your technical and non-technical colleagues to ensure the right technical work is delivered at the right time.

Although this session is geared towards technical advocacy, practitioners of product, design, agile coaching, quality, and all other disciplines are welcome! Anyone involved in cross-functional decision-making and delivery will benefit from understanding the shortcomings of technical debt. Moving beyond technical has benefits for us all.

Close

Kito Mann

---

In life and software development, there’s always something left to do. In coding, this often appears as a TODO comment. TODOs have become a standard part of writing code, so much so that our tools now understand and help manage them.

However, a TODO merely states what needs to be done. We must verify its necessity and ensure it gets done. When should it be done? How important is it? What are the consequences? Is it a future suggestion or a requirement? These are crucial questions often left unasked. Instead, TODOs often become vague comments that persist long after the original developer has left the project or organization.

Perhaps we should limit the lifetime of TODOs to ensure they are resolved or deferred before code is merged. Maybe we need a new perspective on TODOs to prevent losing sight of the potential feature, enhancement, or technical debt they represent. In this session, we’ll explore TODOs in depth and discuss how to ensure they generate outcomes rather than becoming stale, context-free comments in a sea of code.

Close

Kieran Murphy

---

New and changing requirements continue for as long as the software is in use. As software creators, our professional challenge is not only to design, but also to build software that is easy to change. Our code and software must be easy to test, to validate, and to change. Our team members must have confidence to introduce change. Our teams change as rapidly as everything else.

Engineering practices like pair programming, test-first development, and frequent customer collaboration really do help us maintain adaptiveness in our software and code. These practices are not as controversial as they once were, but committing to them is still challenging for any team. A lot of teams start on that journey but not all maintain the commitment.

Teams that do maintain them do so by developing communication patterns, by being strategic about testing, and by shaping the work and to support the practices. And this shaping of the work is where the value is realized.

I have found that maintaining three key practices help us to create a codebase, processes, and communication patterns that support adaptiveness and change:

* Pair programming, with frequent rotation
* Test-first development, with testing strategy
* Frequent showcases, with low ceremony

In this 60 - 75 minute presentation I share methods and learnings drawn from several teams that I have worked with as a developer, tech lead, or coach, in both committing to and maintaining these three practices over the long term, and how these practices informed our designs and our processes.

Using both slides and code, I share:

* Methods to help teams commit to and maintain these and other engineering practices, rooted in value articulation
* A case study about helping multiple teams learn and adopt these practices, the method behind it, and the experiences of three teams involved
* A method for helping your team develop a testing strategy, and how to move from “test all the things” to testing strategically in consideration of your team’s unique environment
* An approach for maintaining weekly feedback sessions with your team's customers
* My own questions for the audience

Who should attend:
* Developers, QAs, PMs, BAs, anyone interested in XP practices

Close

Michael Carducci

---

Software architecture has matured well beyond the days of best practices and “silver bullet” solutions. Complexity abounds, not just in codebases but in the mesh of human factors, business demands, organizational norms, and technological shifts that define real-world systems. Despite the industry’s wealth of patterns and principles, too often these are applied in isolation—leaving architects ill-equipped to address the full breadth of constraints and trade-offs that modern projects entail. This talk argues that a new perspective is needed: one that integrates every dimension of architecture, from technology stacks and communication channels to team structures and organizational dynamics.

Enter the Tailor-Made Architecture Model—a deterministic, holistic framework for architects seeking to meet these growing challenges. By marrying practical decision-making tools with an overarching lens that accounts for social, technical, and environmental realities, this model equips practitioners to design solutions that not only survive but thrive in complex, evolving ecosystems. Attendees will discover how to move beyond abstract theory and deliver architecture that is both resilient and adaptive, bridging the gap between lofty design principles and the inescapable messiness of real-world software delivery. Join us to learn how to master a more comprehensive, integrative form of architecture that respects every aspect of the system—and leaves no dimension overlooked.

Close

Venkat Subramaniam

---

Decisions, decisions, decision, that is our life every day. But, what is worse than making a bad decision is not remembering why we made a decision, good or bad. Architectural Decision Records are highly important to document the decisions we make, to support the decisions, to bring in necessary and sufficient reasons, and to reevaluate decisions when the business requirements and/or the technologies change. In this presentation we will look at ADRs, how to create them, how to maintain them, and the values they provide.

Close

Dan Vega

---

Skip the slides and dive straight into code as we build a full-featured GraphQL API from scratch using Spring Boot. Through live coding, we'll implement essential features including schema-first design, batch loading optimization, virtual threads, and query-by-example filtering. You'll see firsthand how GraphQL solves common REST challenges like over-fetching and endpoint proliferation. By the end, you'll understand not just the basics of GraphQL, but also production-ready patterns for scalability and performance. Perfect for developers looking to modernize their API architecture with practical, battle-tested approaches.

Close

Pranay Singhal

---

As engineers, we obsess over scalability, performance, and fault tolerance — but we often ignore one of the most critical aspects of system design: human comprehension. The best systems aren’t just the most powerful — they’re the ones developers can understand, evolve, and reason about under pressure. This talk explores cognitive load — the mental effort required to work with code and systems — and how it silently undermines developer productivity, increases bugs, and slows down teams. We’ll dive into what cognitive load means in the context of software engineering and how thoughtful design choices can make our systems easier to navigate, maintain, and debug.

Participants will leave with:
--A solid grasp of how cognitive load affects system design
--The ability to spot high-load areas in code and architecture
--Patterns and practices to reduce mental overhead
--Tools and techniques to improve clarity and maintainability
--A renewed focus on designing systems for humans

Close

Mark Richards

---

Microservices is a unique architectural style that promotes the concept of a bounded context, where each separately deployed service owns its own data. This means that other services that need your data cannot access it directly-they must ask the service for the data. In this session you'll learn about 5 different techniques for accessing data from other services you no longer have access to, and different ways of sharing data in a microservices ecosystem.

Close

Raju Gandhi

---

We've all learned that documenting your code is a good idea. But what about your architecture? What should we be thinking about when we document architecture? What tools and techniques can we reach for as we pursue this endeavor? Can we even make this a sustainable activity, or are we forever doomed to architectural documentation getting outdated before the ink is even dry?

In this session we will discuss a range of techniques that will not only help document your architecture, but even provide a mechanism to think about architecture upfront, and make it more predictable. You'll walk away armed with everything you need to know about documenting your current, and future architectures.

Close

Aman Sardana, Vijay Kumar Soni

---

Business-critical systems in payments that support real-time transaction processing are expected to be available and highly responsive 24/7/365. These systems must be fault-tolerant and highly resilient to any failures that might happen during payment transaction processing. Resiliency testing is the key to ensuring uptime and performance under unpredictable conditions.
With customers expecting continuous availability of business-critical systems, the companies must think differently not only how to build reliable systems but also how the critical systems are tested. The companies need to go beyond traditional testing and adopt resiliency testing practices as part of their Software Development Lifecycle.
This talk explores real-world strategies for testing the resiliency of business-critical software systems, including failure injection, chaos engineering and disaster recovery. You will learn how to plan for resiliency tests, proactively test for failures, optimize recovery time, and build reliable systems that can handle extreme loads. This ultimately helps to prevent costly outages, maintain business continuity, and build failure-resistant software systems.
Key Takeaways:
- Understanding resiliency testing and its importance for business-critical systems
- Tools and techniques for implementing resiliency testing
- How to introduce failures in a controlled environment and observe system behavior
- Simulating real-world failures – latency spikes, network disruption, process failures, platform service outrages
- Disaster Recovery and failover for rapid recovery after outages
- Automated Resiliency Testing in CI/CD pipelines

Close

Vladimir Zakharov

---

Enterprise Architects can sometimes feel out of touch with the needs of developers. Perhaps you have seen organizations where all that architects produce is white papers and guidelines, while developers defend their completed work with a presentation during a one-off design review.

Establishing a well-managed Architecture Pattern Catalog can take enterprise architects out of their ivory tower and make their work relevant and impactful. The catalog will guide developers to optimal design and implementation choices, which meet their business and technical requirements.

And you don’t need to start with the first principles! Software engineering is now mature enough that comprehensive pattern catalogs and reference implementations are available from companies like Microsoft, Google, or Amazon. These can be used by an organization to select and fine-tune patterns that are relevant to its needs.

This talk will show how to create and evolve an Architecture Pattern Catalog that connects problem and solution spaces, adheres to organizational standards and biases, and directly supports developers in their work.

Close

Ted M. Young

---

Event-sourcing allows the business to ask questions about your application's data that weren't thought of when the system was created, such as "how often are customers changing their shipping address?". Event-sourcing is like version control for your data, with meaningful commit messages, allowing you to understand not just what the current state is, but how it got there.

In this session, you'll learn how event-sourcing works at the code level without event-sourcing libraries getting in the way of deeper understanding. We'll walk through a codebase for a Concert Ticketing system and see how straightforward the implementation can be.

We'll start with modeling the events, the commands (user actions) that generate them, the aggregates that make business decisions, and the projections used to generate the user interface. We'll look at the (Java) code that implements these concepts, and see how event-sourcing makes testing easier to write and understand.

We'll end by touching on the challenges to using event-sourcing, such as performance and schema evolution (versioning).

Close

Neal Ford

---

book Building Evolutionary Architectures defined the concept of architectural fitness functions, mechanisms that allow architects to verify architecture capabilities such as structure and operations. However, just like Test-Driven Development ensures that a code base has good test coverage, fitness function-driven architecture defines a similar approach in architecture. This session describes how architects can use fitness functions to drive their design rather than verification as afterthought, using case studies (like LMAX) to illustrate the depth and breadth of this technique. This is an example-driven session, showing an existing architecture and how architects might drive both the initial design and migrations via fitness functions. This session also touches on the concept of a Governance Mesh as a way of unifying architecture governance across an enterprise.

Close

Bert Jan Schrijver

---

In software design and software architecture, we often face the question: should we build this in a generic, reusable way, or in a specific way that only solves the current problem we have?
Usually, this is not an easy question to answer. The answer depends on a lot of different factors, including future factors you may not be aware of - yet.
In this talk, I’ll share my experiences and thought process as a developer and software architect with choosing between generic and specific solutions. I’ll talk about generic vs specific design & architecture, both on a project level and organization level. We’ll look at sharing code/components between teams, inner source culture, monorepo’s, microservices, lifecycle management of generic components and strategic design as a tool to help decide. After this talk, you’ll have practical insights that can help you to choose between generic and specific solutions yourself.

Close

Mark Richards

---

Software architecture is full of risk. Will the system scale to accommodate an increase in user load? Is end user responsiveness getting better or worse over time, particularly as changes are made to the system? Is the system as available as it needs to be? Are you at risk for losing orders, particularly at times of peak load? Is the architecture structurally sound? In this session you’ll learn how to perform an architectural risk assessment to determine the level of risk within your systems, particularly as you undergo application modernization and transform your architecture. By leveraging the techniques demonstrated in this session, you can help prevent your systems from eventually breaking down, and, in many cases, simply stop working.

Close

Bert Jan Schrijver

---

Software architecture represents the significant design decisions that shape a system, where significant is measured by the cost of change. At its core, architectural decision-making is about balancing trade-offs to align technical solutions with broader requirements.
But how do you approach a trade-off analysis? How do you choose between different solutions, frameworks, tools, languages, or cloud providers? Which factors should guide your decisions beyond just technical fit? And how do you make sure you’re not overlooking non-technical aspects like team expertise, long-term supportability, and hiring feasibility?
In this session, I’ll share a structured approach to making informed, high-impact architecture decisions. We’ll break down technical, organizational, financial and other trade-offs and explore how to evaluate and balance competing concerns. You’ll walk away with practical strategies to make better architectural decisions in real-world projects.

Close

Rafał Maciak

---

Microservices are often viewed as a silver bullet, but real-world experience tells a different story. In this presentation, I will take you through a journey of both successful and failed large scale microservices implementations I have been part of over the past decade. We will explore how microservices can either simplify or drastically complicate a project, potentially turning it into a nightmare for developers.

This presentation will focus not only on the technical aspects of the architecture, such as dealing with distributed transactions or the challenges of excessive services communication, but also on the often-overlooked need for an organizational shift - adjusting processes and embracing a new mindset. You'll learn what to do and what to avoid to ensure that your microservices journey delivers on its promise of agility and scalability, rather than becoming a complex and overwhelming challenge. All of this is based on real-life examples from various projects of different scales, ranging from monolith to microservices migrations, to managing microservices on a scale of thousands of services.

Close

Marcelo Araujo

---

As organizations increasingly rely on APIs to power digital transformation, the need for consistent, scalable, and secure API management has become critical. However, implementing effective API governance is a complex endeavor fraught with challenges that span technical, organizational, and cultural dimensions. This talk delves into the multifaceted challenges of API governance, including:
1. Balancing standardization with flexibility to accommodate diverse use cases.
2. Aligning cross-functional teams with varying priorities and levels of API maturity.
3. Ensuring compliance with evolving security, privacy, and regulatory standards.
4. Overcoming resistance to change and fostering a culture of accountability.
5. Integrating governance processes without stifling innovation or agility.

Drawing on over 10 years of experience dedicated exclusively to API strategy, governance, and implementation across industries, the presenter will share actionable insights and proven strategies for addressing these challenges. Attendees will gain practical tools to define clear governance frameworks, leverage automation, and promote stakeholder alignment, ensuring scalability, reliability, and long-term success in a rapidly evolving API ecosystem.

Close

Nathaniel Schutta, Glenn Renfro

---

Today you are being besieged by folks telling you that AI is the secret that will solve every problem in your application. But AI is the sauce not the meal, don’t let it drown your application. There is tremendous business pressure to introduce AI into software systems, but architects must navigate the pros and cons to create an architecture that solves business needs today and into the future. Almost any component in your architecture can include AI altering how you design, build and test systems. As an architect you need to be able to design systems to take advantage of AI while limiting the blast radius of approximations.

In this talk we will discuss the decisions that an architect must address when introducing non-determinism into their systems, the tradeoffs involved in using AI, how to engineer solutions with appropriate guardrails and why people remain a critical part of the process. We will also cover the importance of honest and clear communication to ensure stakeholders understand the risks and the benefits as well as the security related concerns generative AI introduces.

Close

Mark Richards, Neal Ford

---

Please changeAll too often we think about the database as “just a place to store and retrieve data”. We tend not to consider the implications of the type of database and the database topology we are using when considering the overall architecture of a system. If the architecture isn’t aligned properly with the database topology, the system will fail to meet its goals and in some cases stop working. In this session you’ll learn the importance of aligning the architecture with the data, and which database types and topologies work with which architecture styles (and which ones don’t). We’ll look at the alignment of monolithic architectures (microkernel and modular monolith), and distributed architectures (microservices, event-driven, service-based, and space-based architecture), and how they align with database types such as relational, key-value, document, columnar, graph, and NewSQL. We’ll also look at how those architectural styles align with various database topologies such as single monolithic databases, domain databases, and the database-per-service pattern, and how to apply fitness functions to govern your data choices.

Close

Nathaniel Schutta

---

Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing...an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?

As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base.

Close

Marcelo Araujo

---

Traditional API linting tools like Spectral, have helped teams identify issues in their OpenAPI specifications by surfacing violations of style guides and best practices. But the current paradigm stops at diagnosis—developers are still left with the manual burden of interpreting warnings, resolving inconsistencies, and applying often repetitive best practice fixes.

This talk explores a transformative approach: using large language models (LLMs) fine-tuned on industry API standards to go beyond pointing out what’s wrong—to actively fixing it. Imagine replacing “Here’s a list of errors” with “Here’s your new spec, clean, compliant, and ready to ship.” By shifting from rule-checking to rule-enforcing via intelligent automation, teams can significantly reduce friction in their design workflows, improve standardization, and cut review cycles.

Close

Jennifer Reif

---

AI models are getting tasked to do increasingly complex and industry specific tasks where different retrieval approaches provide distinct advantages in accuracy, explainability, and cost to execute. GraphRAG retrieval models have become a powerful tool to solve domain specific problems where answers require logical reasoning and correlation that can be aided by graph relationships and proximity algorithms. We will demonstrate how an agent architecture combining RAG and GraphRAG retrieval patterns can bridge the gap in data analysis, strategic planning, and retrieval to solve complex domain specific problems.

Close

Scott Davis

---

As digital spaces become integral to our lives, ensuring their inclusivity is more important than ever. "Bridging the Digital Divide: Empowering Accessibility Through AI Innovations" explores the transformative role of Artificial Intelligence (AI) in making technology more accessible for all. This session highlights how cutting-edge AI technologies, such as natural language processing, computer vision, and machine learning, are driving solutions to bridge accessibility gaps.

From AI-powered screen readers and voice-controlled interfaces to real-time translation tools and personalized learning systems, we will delve into practical examples and inspiring case studies showcasing how AI empowers individuals with diverse needs. Attendees will learn how AI innovations are enabling greater independence, improving user experience, and creating opportunities for meaningful digital engagement.

By the end of this talk, you’ll gain a deeper understanding of how AI can be leveraged to design inclusive technologies, creating digital environments that truly work for everyone.

Target Audience: This session is for Accessibility Advocates, AI and ML Practitioners, UX Designers, and Software Engineers interested in leveraging technology to create inclusive solutions. Product Managers and Policy Makers focused on digital equity and accessibility initiatives will also find valuable insights into the potential of AI-driven accessibility tools.

Close

Bryan Oliver

---

In this talk, we'll look at the complexity of providing a platform engineering experience in an environment made up largely of (very large) GPUs. One of the challenges faced in this type of environment, is that traditional resiliency and fault testing (such as Chaos Engineering) is much more difficult to automate and experiment with.

We are used to the concepts of fault injection and chaos engineering in normal clusters and web api services. Techniques like node shutdowns, cpu exhaustion, memory leaks, etc. are all easy things to automate in Kubernetes (or other orchestration platforms) with open source or proprietary tools. There's not a lot of tooling readily available to create failures in GPUs and GPU Nodes at scale.

We'll look at the challenges, tools, and techniques, as well as our ongoing effort to create an open source toolset for automating chaos on gpus.

Close

Cedric Clyburn

---

As large language models (LLMs) become more accessible, running them locally unlocks exciting opportunities for developers, engineers, and privacy-focused users. Why rely on costly cloud AI services that share your data when you could deploy your own models tailored to your needs? In this session, we’ll dive into the advantages of local LLM deployment, from selecting the right open source model to optimizing performance on consumer hardware and integrating with your unique data.

Let’s explore the journey to your own local stack for AI, and cover the important technical details such as model quantization, API integrations with IDE code assistants, and advanced methods like Retrieval-Augmented Generation (RAG) to connect your LLM to private data sources. Don’t miss out on the fun live demos that prove the bright future of open source AI is already here!

Close

Dan Vega

---

As Large Language Models (LLMs) revolutionize application development, Java developers face a critical challenge: how to securely and efficiently connect these AI models with enterprise data and tools. The Model Context Protocol (MCP) offers a practical solution by providing a standardized approach for integrating AI capabilities into Java applications while maintaining enterprise-grade security and scalability.
Through live coding demonstrations, we'll explore how to leverage Java's MCP implementation to build powerful AI-enabled applications. Starting with basic setup and configuration, we'll progress to building custom MCP servers using Java and create practical features that combine the power of LLMs with Java's robust ecosystem. You'll see firsthand how to connect your Java applications to Claude Desktop and other AI tools while maintaining control over your data and infrastructure.
Attendees will leave this session with everything needed to start implementing MCP in their Java projects: working code examples, best practices for secure AI integration, patterns for building custom MCP servers, and practical strategies for enhancing existing applications with AI capabilities. Whether you're new to AI integration or looking to standardize your approach across the enterprise, you'll gain actionable insights to immediately improve your AI development workflow.

Close

Billy Korando

---

Data is at the center of any organization. So it stands to reason that data should be at the center of how we design and write our Java applications. In this talk we are going to look at how recent changes to the Java language; Records, Pattern Matching, Seal Hierarchies, are enabling Java applications to be written in a Data-Oriented Programming (DOP) paradigm. We will look at the core concepts of DOP, and how it compares and contrasts with the OOP approach familiar to many Java developers.

Close

Lucia Greco

---

Gaming is a universal pastime, and its accessibility features are reshaping the way we understand and interact with digital experiences. This talk will explore the valuable lessons that software developers in various fields can learn from video game accessibility. We will also discuss how these features, initially intended for players with disabilities, have found widespread adoption among the general gaming community.
By examining the evolution of accessibility in gaming, we will uncover unexpected benefits that arise when inclusive design principles are applied. We will discuss how accessibility features, though designed for people with disabilities, enhance the overall user experience for everyone, leading to broader engagement and satisfaction.
This talk aims to highlight the importance of inclusive design beyond its primary audience, demonstrating that accessibility is not just a necessity for some but an opportunity for all. This talk will explore video games and their potential for creating more inclusive applications across various platforms.

Close

Scott Davis

---

If you think you need to download extra apps or utilities to make your smartphone or laptop more accessible, think again! This session will introduce you to the built-in accessibility features already available on your device. Whether you're using an iPhone, Android, Windows laptop, or MacBook, you'll gain hands-on experience with powerful tools designed to make digital interactions more inclusive.

Key Takeaways

Hands-on experience with screen readers like VoiceOver (iOS & MacOS), TalkBack (Android), and Navigator (Windows).
Exploring voice control features to navigate your devices completely hands-free.
Understanding built-in accessibility tools and how they can improve usability for everyone—not just those with disabilities.
Target Audience

This session is perfect for developers, UX designers, product managers, and accessibility advocates looking to deepen their understanding of device-native accessibility tools. It’s also ideal for anyone interested in making digital experiences more inclusive without additional software.

Close

Aman Sardana, Vijay Kumar Soni

---

The core platform systems support business-critical applications and they are expected to be available and highly responsive 24/7/365. As an example, financial institutions with legacy infrastructure are increasingly adopting Hybrid cloud solutions to stay competitive, balance scalability, drive cost-efficiency, and achieve regulatory compliance. However, this shift introduces significant challenges related to system performance, security, and compliance. These challenges must be addressed with strategic mitigation measures.
In this talk we’ll share insights, experiences, and innovative solutions to successfully navigate Hybrid cloud challenges in Financial Technology domain for core backend processing systems, Open Banking, payment processing etc. Attendees will gain practical strategies for securing hybrid environments, ensuring compliance with financial regulations, and optimizing performance across distributed cloud ecosystems. These strategies can be applied to any industry vertical that operates critical infrastructure with hybrid cloud deployments.

Key Takeaways:
- The importance of hybrid cloud in modern FinTech operations
- Hybrid cloud architecture and infrastructure best practices
- Data Management and Governance
- Security considerations and risk management in hybrid cloud environments
- Compliance and regulatory challenges (PCI-DSS, GDPR etc.)
- Performance optimization strategies for financial workloads in hybrid cloud deployments
- Business Continuity, Disaster Recovery and Resiliency of critical infrastructure
- Cost management and FinOps
- Vendor Lock-In and Dependency

Close

Craig Walls

---

You can't improve what you can't measure.

Modern application observability involves tracking key metrics and tracing the flow of an application, even across service boundaries. Spring Boot 3 introduced some powerful metrics and tracing capabilities based on Micrometer to open a window into your application's inner-workings.

Among the things you might want to keep an eye on in your Generative AI applications are how many interactions and how much time is spent with vector stores and AI provider APIs and, of course, how many tokens are being spent by your application. And being able to trace the flow of prompts, data, and responses through your application can help identify problems and bottlenecks.

Great news! Spring AI comes equipped to record metrics and tracing information through Micrometer. In this session, you'll learn how to put Spring AI observability to work for you. You'll learn about the metrics it exposes as well as the keys you can use to build dashboards and tracing to build a window into your Generative AI applications.

Close

Raju Gandhi

---

Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?

In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future

Close

Eric Deandrea

---

In this session, I will show concepts and conventions familiar to Spring developers and how those same concepts and conventions can be implemented in Quarkus, all while highlighting similarities and differences between them. Additionally, I will show similarities and differences in how testing is done, highlighting Quarkus Dev Services.

This session will be mostly live coding while minimizing the amount of slides. I will introduce an existing Spring application with a full test suite and build a Quarkus equivalent version of it, live, while showcasing similarities and differences between the two frameworks.

Close

Viktor Gamov, Baruch Sadogursky

---

Agentic AI-driven IDEs promise cleaner code, faster development, and fewer late-night debugging sessions. But do they really deliver?

In this live showdown, two developers will each use a different cutting-edge AI coding environment (we'd name them, but honestly, things move too fast in this space) to complete identical coding tasks, from initial setup to testing and debugging, all live on stage.

You, the audience, decide which tool actually boosts quality and productivity and which just creates more noise than useful code. Bring your skepticism, cast your vote, and expect surprises.

Close

Brian Vermeer

---

Modern Java applications increasingly incorporate Large Language Models, but with great power comes great security responsibility. This session cuts through the hype to deliver practical security strategies specifically for Java developers working with LLMs. We'll examine real-world vulnerabilities like prompt injection and data leakage that directly impact your codebase alongside practical demonstrations of how traditional application security flaws can be amplified when combined with AI capabilities. You'll walk away with concrete implementation patterns to protect sensitive data, maintain regulatory compliance, and build robust permission boundaries - all within familiar Java frameworks and tools. Whether integrating external AI services or deploying your own models, this session provides the security foundation you need to confidently ship LLM-powered features without compromising your application's integrity.

Close

Barry Burd

---

In a peer-reviewed paper published on March 12, 2025, D-Wave announced that its "quantum computer outperformed one of the world's most powerful classical supercomputers" in solving a useful materials science problem. As breakthroughs like this continue, quantum computing is no longer just a theoretical curiosity — it's becoming a practical reality, with the potential to shatter the limits of classical computing.
But quantum algorithms don’t just run faster — they run differently. In this talk, we’ll break down the core concepts of quantum computing, from superposition to entanglement, and show how these new ideas map to code. We'll use Java and the aptly named Strange library by Johan Vos to explore how you can start experimenting with quantum logic using familiar tools. Whether you're a Java dev or a quantum-curious engineer, you'll walk away with a clearer understanding of how the future of computing is unfolding — one qubit at a time.

Close

Ramnivas Laddad

---

Large language models (LLMs) are powerful--but only when they have access to the relevant context for the task at hand. While techniques like Retrieval Augmented Generation (RAG) help bridge this gap, they have limitations in the types of questions they can answer and the tasks they can perform. The Model Context Protocol (MCP) offers a simple, open standard for connecting AI models to real-time information and tools, enabling them to go beyond static knowledge.

In this talk, we’ll explore the core concepts of MCP: how it works, how it extends the capabilities of LLMs by enabling interactions with external resources, and how it fits into the broader AI ecosystem. We’ll then dive into applying MCP in real-world scenarios--covering topics like standards-based authentication, access control, and blending fluid AI-driven interfaces with deterministic systems. By the end, you'll have a good understanding how to leverage MCP effectively without compromising on data integrity or security.

Close

William Lyon

---

In much the same way that the concept of cloud-native computing changed the abstractions that developers use to design and build applications, the adoption of AI is driving a new paradigm of AI-native application architecture. This talk will present an overview of the AI-native architecture that is emerging for enterprises putting agentic apps into production.

Close

Jonatan Ivanov

---

In this talk, we will discuss some of the most common ways software fails and some of the most creative and unusual failures I have seen over the years. We will explore the unpredictable world of production so that you will learn how to avoid these pitfalls, reduce risk, fail confidently, understand the biases we all have built-in when we design or troubleshoot these systems. You will also learn how to spot a memory leaks or things that look like a memory leak but they aren't. You will also learn about how lesser known Observability signals can help you to get out of trouble. This talk is for anyone who has ever worked in production or plans to do so: Software Engineers, DevOps, QA, and anyone responsible for deploying and maintaining software. If you have ever caused a production incident or are afraid of it, this talk is for you. Join us to learn from these mistakes and avoid making them yourself.

Close

Bryan Oliver

---

Delivery systems such as Jenkins or Circle, are software. And that software has an architecture.

In this talk, we'll analyze the architectural patterns essential for building state-of-the-art delivery systems. In 2025, state-of-the-art includes incredibly complex multi-region topologies while simultaneously requiring us to provide incredible developer experiences and intelligent orchestration of their deployments.

- We'll understand the patterns behind current delivery systems and the strategies they enable
- We'll look at the potential of delivery patterns within systems, assessing capabilities and limitations
- And we will gain a profound grasp of the architectural components that constitute effective delivery systems

Leaving this talk, you will be able to choose suitable delivery systems and patterns, optimizing for both function and efficiency, and identify effective patterns and antipatterns, so you can implement robust delivery systems.

Close

Billy Korando

---

Some of the most difficult issues a developer will face are slow developing resources leaks, or errors that occur at infrequent intervals. When these happen, finding the root cause can be difficult, and a frequent recourse by developers is to add a lot of logging statements around suspected problem sites. What if I told you there was a better option, and that option already existed right in the JVM you are already running? JDK Flight Recorder, as its namesake suggests, is a low-overhead profiling and diagnostic tool that[s been built directly into the JDK since JDK 7. In this presentation we are going to look at how developers can leverage JFR's powerful API and reporting tools for tracking down those difficult bugs as well as how JFR can be incorporated into the development process.

Close

Jonatan Ivanov, Pasha Finkelshteyn

---

The difference between JVM mastery and mystery? It’s Observability that actually works. If you are tired of squinting at logs when your Java app goes wild. Join us for an example-driven journey through the JVM observability landscape. We'll show you how combining traditional (JMX) and cutting-edge observability techniques leads to faster problem resolution. You’ll learn how to address the frustrations of CPU spikes, memory loss, errors and latency. We'll use Logging, Metrics, and Distributed Tracing to dig into the nitty-gritty of your apps.

Close

Cedric Clyburn

---

Today, Kubernetes is the undisputed go-to platform for scaling containers. But for developers, Kubernetes can be daunting, particularly when working with the discrepancies between local and production environments. As new Cloud Native Computing Foundation (CNCF) Sandbox projects, Podman and Podman Desktop bridge this gap as open source projects to work with containers and beyond!

In this talk, you’ll be introduced to Podman and witness the unveiling of Podman Desktop, an open-source GUI tool that streamlines container workflows and is compatible with Podman, Lima, Docker, and more. Podman Desktop serves as a beginner-friendly launch pad to Kubernetes, enabling developers to spin up local clusters (with Kind and Minikube) or work with remote environments. A demo will be given that helps you navigate the paths necessary to transition from app to containers, to pods, and ultimately to Kubernetes, highlighting how it reduces discrepancies and enables predictability in your deployments across the hybrid cloud. You'll learn how developers and operations don't need to be Kubernetes experts to take advantage of the benefits of cloud-native computing, and streamline your container development process!

Close

Bert Jan Schrijver

---

Short version: I'll show you everything you need to know about the Linux command line as a developer.

Long(er) version:
As a developer, you often have to deal with Linux servers. Troubleshooting, digging through logs, editing configuration files, you name it. If you're used to working with Windows or OSX GUI's, the Linux terminal might appear fairly basic and difficult to use. But, with some basic background knowledge and a small set of terminal commands in your toolbox, it can actually be extremely powerful and loads of fun!

In this session, I'll explain the concepts behind the Linux command line and I'll demo loads of useful stuff. You'll learn how to quickly navigate, find files, examine and search through logs, how to investigate a system under load, a bit of shell scripting, ssh tunneling and more!

This talk takes places entirely in the command line. No slides, no IDE, just a plain terminal window. After this session, you'll be on your way to master the Linux command line yourself!

Close

Daniel Hinojosa

---

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

In this presentation, we tell a story.

I want my group to use the same language and tool versions exactly and repeatedly; I don't want to hear, "It works on my machine." It should work on all machines and CI/CD.

* Wait, is this like Docker?
* Installing and Using Nix
* How to use `nix-shell`?
* Finding our software in the nix-store
* Establishing a _default.nix_ file
* Using other nix commands
* Programming Nix
* Using Nix with Docker

Close

Craig Walls

---

You can't improve what you don't measure.

As applications grow and become more complex, it's increasingly important to see what's going on inside. In this session, you'll learn how to put Micrometer and Spring's Actuator to work, enabling you to see, monitor, and take action on the internal activities of your Spring applications.

Historically, we've relied on application logs to understand what an application is doing, to measure its performance, and troubleshoot issues. Although logs can provide valuable insight, it only helps you see what happened in the past, not what's happening right now. And typically the most helpful log entries (those at DEBUG level) are disabled in a production application.

Modern application observability involves tracking key metrics and tracing the flow of an application, even across service boundaries. Spring Boot 3 introduced some powerful metrics and tracing capabilities based on Micrometer to open a window into your application's inner-workings.

Close

Craig Walls

---

Spring Security has long been a powerful guard to place around your Spring applications, providing authentication, authorization, and many more concerns around keeping your application secure. As time has progressed, Spring Security has evolved to provide even more capabilities, but has applied some self-improvement to make working with Spring Security even easier. That is to say, the way you configure and apply Spring Security today has changed dramatically from it's early XML-oriented approach and is even different now than some of the more recent Java-based configuration strategies. In this example-driven session, we'll explore the latest and greatest that Spring Security has to offer, with an emphasis on how to apply security aspects to your applications with the latest configuration styles supported by Spring Security. You'll see how security is enabled in modern Spring applications using the Lambda DSL configuration approach, the preferred way to configure Spring Security and the ONLY way to configure Spring Security 7.

Close

Adele Carpenter

---

Using Java as an everyday language can be absolutely infuriating. It's verbose and clunky, with all roads seemingly pointing to null. These are faults that users of other languages (especially of C#) love to point out.

At the same time, Java is mature, stable, backwards compatible, and runs just about anywhere. The community is pretty cool too!

This talk takes a light-hearted, warts-and-all look at some of the more frustrating aspects of Java, how the language has evolved over time and where it's headed next.

Expect to laugh, and yes maybe even cry, as we try to make sense of the beast that puts food on the table for millions of developers worldwide

And if you're not currently a Java user, don't worry, we will explore the consequences of language design decisions in broad enough terms that you will still get a lot out of this talk!

We will cover:
- Pivotal early design decisions such as checked exceptions and generics and how we still pay for those decisions today (that is, why do lambdas suck so bad?)
- How Java has influenced the development of other programming languages, and vice versa
- Most controversial language design decisions of late and the associated fallouts

Java developers will leave this session feeling validated and with a renewed love for the language that keeps a large chunk of the world running. C# developers will leave this session with a renewed level of smugness.

Close

Simon Ritter

---

May 23rd, 1995, saw the launch of not just a new programming language but an entire development and deployment platform. Initially targeted at the brand-new world of browsers and the World Wide Web, it quickly became the de facto standard for internet-scale enterprise applications.

Remarkably, thirty years later, it is still always in the top three most popular languages in use by developers.

How did this happen?

In this session, we’ll take a whirlwind tour of the history of Java, recalling many of the milestones along the way.

I started working for Sun Microsystems in February 1996, roughly the same week JDK 1.0 was launched. Through fourteen years at Sun, five at Oracle and nine at Azul, I’ll bring plenty of anecdotes (and some souvenirs). Be prepared for some serious developer nostalgia!

Close

Rodrigo Graciano

---

In large enterprises, Java developers do much more than write code. They’re also responsible for meeting company-wide standards—fixing vulnerabilities, upgrading frameworks and Java versions, and ensuring quality metrics like code coverage, technical debt, and security are in check.

These tasks, while critical, often compete with feature development and can slow teams down. The good news is that a growing set of developer-friendly tools—both open-source and commercial—can help. From static code analyzers to automated testing, framework migration, and vulnerability detection tools, developers now have powerful allies to handle routine, compliance-heavy tasks efficiently.

This talk explores a set of practical tools that integrate well into Java development workflows, helping teams ship better code faster while meeting organizational requirements. You’ll leave with actionable insights on boosting productivity, improving software quality, and making compliance a seamless part of the development process.

Close

Josh Long

---

The age of artificial intelligence (because the search for regular intelligence hasn't gone well..) is nearly at hand, and it's everywhere! But is it in your application? It should be. AI is about integration, and here the Java and Spring communities come second to nobody. In this talk, we'll demystify the concepts of modern day Artificial Intelligence and look at its integration with the white hot new Spring AI project, a framework that builds on the richness of Spring Boot to extend them to the wide world of AI engineering.

Close

Josh Long

---

Spring Boot 3.x and Java 21 have arrived, making it an exciting time to be a Java developer! Join me, Josh Long (@starbuxman), as we dive into the future of Spring Boot with Java 21. Discover how to scale your applications and codebases effortlessly. We'll explore the robust Spring Boot ecosystem, featuring AI, modularity, seamless data access, and cutting-edge production optimizations like Project Loom's virtual threads, GraalVM, AppCDS, and more. Let's explore the latest-and-greatest in Spring Boot to build faster, more scalable, more efficient, more modular, more secure, and more intelligent systems and services.

Close

Loïc Magnette

---

Working on web projects often means dealing with two separate environments —one for the backend and another for the frontend —each with its own ecosystem. Developers frequently encounter issues when dealing with their counterparts' ecosystems, creating a needless wall between front-end and back-end developers. You have to use unfamiliar tools, follow API changes, create mocks, and have a hard time creating e2e tests. Overall, this makes development unnecessarily frustrating and a time-consuming process.

In this session, I'll discuss your approach to these typical problems and show you how Quarkus makes full-stack development easier. Without having to deal with typical npm or front-end setup issues, Quarkus allows you to develop applications with dependable Java back-end services and javascript front ends. You can concentrate on more important things, like building your app!

Using a Java backend powered by Quarkus and a JavaScript front end, we will learn how to build a full-stack application.

Close

Viktor Gamov, Baruch Sadogursky

---

Which Java framework handles AI better: LangChain4j or Spring AI? In this live coding showdown, we’ll build a semantic code search application from scratch, putting both frameworks to the test. We’ll cover project setup, using language models, setting up a retrieval-augmented generation workflow, and creating a REST API.

You’ll see how these frameworks handle embedding generation, vector database integration, and real-world development challenges. By the end, the audience decides who wins—based on which framework gets the job done faster, better, and with less hassle (and whether the demo actually works).

This isn’t just a comparison; it’s a live experiment under pressure. Come and see which one comes out on top!

Close

Brian Vermeer

---

Securing your Java application isn’t just about protecting against vulnerabilities, it’s about building a foundation of clean, maintainable code that inherently promotes security. Clean code is not only maintainable and scalable but also secure, minimizing the likelihood of introducing flaws that attackers can exploit. Creating a secure Java application isn’t a one-time task; it’s an ongoing commitment to improving your security posture. Simple steps, like carefully choosing your libraries, scheduling regular maintenance, optimizing your build pipeline, and learning to spot vulnerabilities like path traversal risks, can make a significant difference. Whether you’re working on a new greenfield project or trying to improve a legacy application that you need to keep running, this talk will equip you with actionable strategies to enhance the security and safety of your Java systems.

Close

Ties van de Ven

---

There are a lot of talks about the newest tools libraries and frameworks but sometimes it is good to take a step back and think about the underlying problems they are trying to solve. In this talk we will go into the 4 fundamental aspects within software engineering; problem solving, managing state, managing errors and managing side effects. There will be almost no functional programming terminology used but instead focus on recognizable examples (in Java) and look at them from a different angle that you might have never concidered. So if you want to improve your problem solving skills and get better in abstract thinking without having to learn what a monad is, this is the talk for you.

Close

Haoyi Li

---

The Java language is known to be fast, safe, and easy, but Java build tools like Maven or Gradle do not always live up to that expectation. This talk will explore what "could be": where current Java build tools fall short in performance, extensibility, and ease of use, and why there's room to improve. We will end with a demonstration of an experimental build tool "Mill" that makes use of these ideas, proving out the idea that Java build tooling has the potential to be much faster, safer, and easier than it is today.

Close

Venkat Subramaniam

---

The Stream API has a wealth of methods, like filter, map, takeWhile, limit, and so on, to build functional pipelines. Yet, you may run into situations in your applications that readily do not fall in place to make use of these built-in methods. The new gatherer() function, along with the Gatherer interface, gives you the necessary tools to create your own custom steps in the functional pipeline. In this presentation, learn about the different types of gatherers and how to implement them using practical live-coded examples.

Close

Paul Bakker

---

The Netflix architecture and the way we use Java is ever-changing. On top of that, Java itself and the OSS ecosystem is changing faster than ever. In this talk, you’ll learn how Netflix is using Java in 2025 and what benefits and possible issues we’re seeing running most of our services on the latest Java releases. You’ll learn about how we build our services with Spring Boot, DGS/GraphQL, and gRPC. We’ll go into dependency management and how we keep over 3000 Java services on the latest versions of frameworks and libraries, as well as the JDK itself. You’ll learn about our experiences with the new garbage collectors like generational ZGC, Virtual Threads, our view on native images, and how we see the near future of building Java services.
We'll also discuss how we're dipping our toes in leveraging Gen AI for development and migration work.

Close

Ted M. Young

---

Tests are code, too, but don't get as much attention as production code, often leaving messy, hard to understand tests. Poorly factored tests can also make refactoring production code that much harder.

In this session, we'll start with what we need from a good test, using AssertJ and JUnit features to make it readable and maintainable. We'll walk up the ladder from Helper methods, shared Factory Methods, all the way to Test Data Builders, using automated refactoring tools to easily make the transition. We'll look at test "smells" and how to repair them, using Parameterized Tests, finishing with how to "retarget" your tests when extracting a new production class from existing code.

Close

Daniel Hinojosa

---

In this session, we will discuss the Vector API in preview in Java. We will begin by introducing SIMD (Single Instruction/Multiple Data) and explore how it can be used to maximize computation speed. The session will then cover the setup for using the Vector API, including establishing a species, defining and using components and lanes, and applying masking with different strategies. We will also discuss same-lane and cross-lane computation. Finally, we will conclude by presenting metrics comparing the performance of using the Vector API versus not using it.

Close

Pratik Patel

---

Please changeBuilding performant and scalable Java applications involves several key strategies from that span from coding, to architecture, to deployment. In this session, we’ll start at a high level and dive deep into code and talk about scaling. We’ll cover these topics:
1. Code Profiling and Bottleneck Identification
2. Efficient Coding Practices
3. Caching and Connection Pooling
4. Memory Management and Garbage Collection
5. Scalability Techniques
After this session, you’ll have specific techniques you can apply to your own Java applications to make them run with lower latency, faster throughput and higher stability!

Close

Barry Burd

---

Java has long been the powerhouse behind enterprise applications — but its reach extends far beyond the server room. It’s also quietly powering some of today’s most exciting and impactful Internet of Things (IoT) innovations. From managing fleets of autonomous underwater vehicles to ensuring interoperability in modern healthcare systems, from monitoring remote environmental sensors to running smart home gadgets, Java is in the mix.
In this session, we’ll explore the surprisingly decisive role Java plays in IoT. We’ll start with a quick tour of real-world Java-based IoT projects across industries, then shift gears into a live demonstration where code meets hardware. With physical devices on stage (yes, we'll bring some toys!) and a little help from the cloud, we’ll show how connected devices share data, respond to real-time input, and form the foundation of modern distributed systems.
If our Wi-Fi connection cooperates, you’ll see devices talking to each other live. Whether you're a Java veteran or new to embedded systems, you’ll leave with a better sense of how to bring your Java skills into the world of connected things.

Close

Simon Ritter

---

Java bytecodes and class files deliver on the original vision of “write once, run anywhere”. Using a Just-in-Time (JIT) compiler allows JVM-based applications to compile only the code that’s being used frequently and optimise it precisely for how it is being used. Using techniques like speculative optimisation can often deliver better performance than static, Ahead-of-Time (AOT) compiled code.

However, this flexibility and performance comes at a cost. Each time the JVM starts an application, it must perform the same analysis to find hot spots of code and compile them. This is referred to as the application warmup time.

In this session, we’ll look at several approaches to how this problem can be alleviated or even eliminated. Specifically:

• Static compilation of Java code ahead-of time (AOT). Specifically, the Graal native image approach
• Generating a JIT compiler profile of a running, warmed-up application that can be reused when the same application is restarted, eliminating the need for much of the JIT compilation. This will include details of the work of the OpenJDK Project Leyden.
• Decoupling the JIT compiler from the JVM for a Cloud environment. Providing a centralised JIT-as-a-Service allows caching of compiled code and offloading the compilation work when new code must be compiled.
• Creating a checkpoint of a running application. This includes all application state (heap, stack, etc.) in addition to the JIT-compiled code. Project CRaC will be used as an example.

At the end of the session, you’ll be all set to keep your Java hot!

Close

Josh Cummings

---

Imagine if you could be a fly on the wall as a security professional walks through a real-life GitHub application and makes the needed repairs to secure it?

In this talk, Josh Cummings from Spring Security will take an anonymized real application from GitHub, talk through his assessment of where it is insecure, why it's insecure, and will then repair those vulnerabilities using idiomatic Spring Security.

No previous experience is necessary. You will walk away with an understanding of the security principles at play in your application and why security frameworks are written the way they are to protect your users.

Close

Venkat Subramaniam

---

We rely heavily on polymorphism when programming with the object-oriented paradigm. That has served us really well, especially to create extensible code. However, like any tool and technique, there are times when that may not be the right choice. Java now provides an alternative that is useful in those select situations—the data-oriented programming. In this presentation we will start with an example where the highly useful object hierarchy and polymorphism appears as a misfit and discuss how data-oriented programming solves the problem more elegantly. Get a good understanding of when to use each one of these and how to intermix them in your applications.

Close

Daniel Hinojosa

---

Property-based testing isn't about testing one set of inputs and asserting an output; it is about testing many random inputs and asserting against a property or rule of what you are trying to achieve. You can use property-based testing against domain code or computation, but we will explore databases in this session.

First, we will discuss the principles of property-based testing (PBT) using JQwik. Then, we will discuss what `Arbitrary` is and how to use it to create custom objects for our test. We will then wire it together with Test Containers, which bootstraps actual databases of your choosing, thus giving us a complete solution and helping us deliver quality in our repository code.

Close

Vladimir Zakharov, Donald Raab

---

Looking for ways to optimize your Java applications? Want to see tangible memory savings as well as cleaner, more readable code?

Eclipse Collections, a drop-in replacement for the Java Collections framework, will do just that!

Eclipse Collections has optimized JDK-compatible List, Set and Map implementations with a rich API. It also adds types not found in the JDK such as Bags, Multimaps and BiMaps. Eclipse Collections has a full complement of primitive containers, and all collection types have immutable equivalents.

Immutable collections allow for safer, cleaner, mutation free code checked at compile time and without runtime surprises. With the combination of immutable collections and the rich API you can write better functional code in Java.

In this session, you will follow a live coding demo of refactoring standard Java code to Eclipse Collections where you will observe the same kind of reduction in boilerplate code and memory savings that you can achieve in your applications.

Close

Frank Greco

---

As developers, we know our day-to-day work extends far beyond writing code. We prototype, write tests, document our systems, sit in meetings, respond to emails and text messages, and produce status updates for our managers. One of the most frequent and often time-consuming tasks is the search for relevant information, ie, semantic searching. This information can be anywhere: inside text files, PDFs, images, transcribed audio from videos, or even information from a website.

While GUI-based search tools are valuable, many developers live and breathe in the command-line environment. However, traditional Unix/Linux utilities like find or grep fall short when it comes to understanding context. This is where language models and embeddings are extremely valuable for software developers as part of the overall development process.

This talk describes implementing a command-line tool that uses semantic retrieval and natural language generation into a useful CLI tool to help software developers optimize everyday searching.

Close

Ties van de Ven

---

“Failed to Load ApplicationContext” is an error we see a lot, but what does it mean? In this session we will go into the basics of Spring Framework, what mental model you need to reason about Spring and how Spring does it’s magic under the hood. We will learn about the application context, what problems it solves, different ways to create beans and the real power behind Spring Boot: conditional bean loading. So if you like a deeper understanding and a better mental model about how Spring works explained in a beginner friendly way, this is the talk for you.

Close

Eric Deandrea

---

Everyone loves writing tests, don’t they? How do you write good tests? What tools are available for you to write good tests?

In this session, I will dive into the many features of Quarkus that help developers write good tests. I will highlight some of the features of Quarkus, Dev Services and Continuous Testing, which help make testing easier. Additionally, I will live code some tests for common use cases developers encounter, including unit, integration, and “black box” testing of imperative and reactive RESTful and event-driven applications that use common services, such as databases and Kafka brokers. I will discuss techniques such as mocking, spying, and interaction-based testing/verification.

I'll even spend some time showing how IDE-based AI assistants can help!

Once you see how easy TDD really can be there isn't a reason to not do it!

Close

Ivar Grimstad

---

Over the last 30 years, Java has been the preferred technology for developing enterprise applications. Frameworks and approaches such as J2EE, Spring Framework, Java EE, Spring Boot, and Jakarta EE all contribute to this success story.

The Jakarta EE 11, with features for increasing performance and developer productivity, such as support for virtual threads and the new Jakarta Data specification.

This session will give you a history lesson of Enterprise Java as well as an overview of everything brought to you by Jakarta EE 11 with lots of code demos. We will also look forward and check out what's in the pipeline for Jakarta EE 12.

Close

Andrew Murphy

---

Burnout in engineering teams is rarely caused by a single event. Instead, it’s the result of persistent, often overlooked management habits that quietly erode motivation, well-being, and performance. Here are 9 habits, why they matter, what happens if you ignore them, and actionable tips to build a healthier, more sustainable engineering culture.

Close

Garima Agarwal

---

In the fast paced world of technology, coding is just one part of the equation for success, yet many women find themselves plateauing in technical roles, often stuck on a slower career trajectory. They excel as coders but miss the opportunity to step into leadership, influence, and visibility that could propel their careers to the next level.

This session will challenge that norm. We’ll explore why so many women in tech remain confined to coding roles, how to break out of that mold, and the powerful strategies to accelerate your career by expanding beyond the code. From building a personal brand to mastering networking, attending key conferences, joining influential groups, I’ll cover it all.

You’ll learn, how to actively grow your network, and how to use your skills to build influence and leadership that goes beyond your technical expertise. By sharing insights, and actionable steps, this session will empower you to break barriers, elevate your career, and start owning your narrative in the tech world.

Close

Atiq Amjad

---

This presentation explores how distributing decision-making authority across organizational levels can transform workplace dynamics and outcomes. We'll examine the core principles of decentralized leadership—empowerment, accountability, and transparency—and demonstrate their impact through case studies from innovative companies. The session addresses common implementation challenges and offers practical strategies for transitioning from traditional hierarchies. Participants will learn how decentralized leadership can accelerate decision-making, foster innovation, improve employee engagement, and enhance organizational agility in today's rapidly changing business environment. Suitable for leaders at all levels seeking to build more responsive, creative, and resilient teams.

Close

Andrew Murphy

---

Conflict is a natural and inevitable part of working in teams, and as leaders it’s important to understand how to recognise and resolve both unhealthy and healthy conflict. In my experience, understanding the difference between these two types of conflict, and how to move between them, is key to creating a productive and collaborative team environment.

In this talk, I’ll cover the negative impacts of unhealthy conflict and the positive impacts of healthy conflict. I’ll discuss how to recognise and understand the differences between the two, and how to move from an unhealthy to a healthy conflict. I’ll also provide a model to help you move from an unhealthy conflict to a healthy one.

Healthy conflict is essential for teams to thrive, and I believe that it’s one of the most important skills for leaders to develop. It’s how we can make a positive impact on our teams and our organisations.

Close

Tobias Modig

---

Turning old as a developer is hard. It is hard to stay relevant, hard to keep up with the competition of newcomers and hard to know all of those new frameworks, tools, languages and practices. However, the truth is that we oldies have a big advantage over the younglings.

We are slow! Slow is good! So whatever you do, don’t put your programming on the shelf just because someone half as old writes code with twice the speed.

Instead of getting frustrated over the pace of the oldies I really believe that we need to take a step back, embrace the skill of being slow and change the developer mindset to understand that the best way to go fast in the long run often is to be “controlled slow” in the short run.

In this highly interactive talk I will elaborate on the danger with the traditional “software developer life cycle” (developer -> team lead -> project leader -> manager) and try to show how we instead can make those grey hairs your biggest asset, just by slowing down.

Close

Fatima Taj

---

We all do things in our day-to-day work that are deemed ‘non-promotable’ - these are tasks crucial for project success but might not get you promoted. This is commonly known as glue work, a term coined by Tanya O’Reilly. Your first instinct might be to drop these tasks immediately, but this isn’t always the best approach. Being glue doesn’t have to mean the end of your career, nor is it something you can’t recover from. During this talk, I will use a personal experience to illustrate how I narrowly avoided being permanently stuck with glue work and how to salvage a situation where you might find yourself in a similar predicament.

Close

Roy Wasse

---

How good of a developer are you?

Are you a good Java developer? What makes a good developer? And how can we measure this?If you ask Oracle they'll say OCP (Oracle Certified Programmer), which means that you know when the compiler makes those red squiggly lines in your IDE disappear.If you ask FAANG companies it means you can balance a binary tree on a whiteboard.All of these methods involve some knowledge and memory, but have very little to do with actual day-to-day programming, technical skill, problem solving and creativity. And.. don’t you think it’s annoying you have to take all these technical tests even though you’ve been coding for many years? In this talk we'll describe our long journey to find a better way to test software development skills; a model based on scientific research, to measure actual coding skills, in a realistic environment. Demo included.

Close

Fatima Taj

---

Ever found yourself overwhelmed and frustrated when mentoring a junior engineer, feeling like you're doing double the work? You're not alone. In this session, I’ll share the story of how a challenging collaboration pushed me to the brink of burnout and what I learned when I finally decided to speak up. Through real-world insights, I'll walk you through the strategies I used to turn things around, including how to provide effective feedback, when to escalate issues to management, and the surprising power of mentorship to transform both performance and team morale.

Join me as we explore the tough, but necessary, conversations that make us better leaders, and leave with actionable steps to navigate your own difficult team dynamics—without losing your sanity.

Close

Paul Bakker

---

Being a Platform Engineer is challenging. Your goal is to create leverage for the entire engineering organization, but your customers (other teams in the company) often have a wide variety of needs and wishes. How do you prioritize a large feature used by a few against a smaller feature used by many?
We’re also responsible for keeping the tech stack modernized so that developers can take advantage of the JVM's best features. But how do you balance modernizing the tech stack with maintaining the platform's stability? How to deal with tech debt and manage breaking changes?

In this presentation, you will hear from Java Platform @ Netflix about how we manage our Java stack for over 3000 applications. We’ll discuss migrations, upgrades, and tooling that can make changes easier for teams. We’ll also cover using and maintaining OSS frameworks as part of an internal platform.

We’ll also look at how to measure success. Metrics sound great, but developer productivity is notoriously difficult to measure.

While this presentation's lessons come from operating in a large platform team, the principles also apply to much smaller teams, even when there isn’t an official “platform” team.

Close

Michael Carducci

---

When speaking at conferences, there are questions that seem to come up again and again. One common example is “How do we determine which new tools and technologies we should focus our energy on learning?” another is “How do we stop management from forcing us to cut corners on every release so we can create better and more maintainable code?” which, after awhile becomes “How can we best convince management we need to rewrite the business application?”

There is a single metaanswer to all these questions and many others.

It begins with the understanding that what we as engineers value, and what the business values are often very different (even if the ultimate goals are the same) By being able to understand these different perspectives it's possible to begin to frame our arguments around the needs and the wants of the business. This alone will make any engineer significantly more effective.

This session answers the question, how do we align the values of the business with the needs and values of the engineer.

Close

Christina Aldan

---

Emotional resilience is the key to navigating life’s inevitable chaos. Learn how uncertainty, chaos, and disruption can be transformed into opportunities for personal growth and fortitude. Get strategies anyone can adopt to build emotional resilience, regardless of where they are in their life and career.
Through a combination of practical tools and personal anecdotes, Christina teaches audiences how she learned to embrace uncertainty, break free from limiting beliefs, and use adversity as a springboard for personal and professional transformation, despite her late-age mental illness diagnosis.
Storytelling using real-world examples make this an unforgettable session for anyone seeking to unlock their potential in the face of chaos.

Close

Sean Denton

---

The tech industry is undergoing a seismic shift, with rapid AI integration and widespread layoffs creating an environment of uncertainty and fear. This upheaval has profound implications for the mental health of professionals, as job insecurity and the pressure to adapt to new technologies take their toll. In this talk, I will explore the psychological impact of these industry changes, sharing real-life stories that underscore the human cost of our evolving work landscape. Attendees will gain insights into the challenges faced by individuals during such transitions and learn strategies to foster resilience and well-being. By addressing the often-overlooked emotional ramifications of technological advancement, this session aims to equip professionals with the tools to navigate change while maintaining mental health and to encourage organizations to prioritize employee well-being during periods of transformation.

Close

Kito Mann

---

If you talk to the most well-known developers, whether they’re people within your organization or internationally recognized experts, you’ll find something in common: they’re productive. Usually, it isn’t just dumb luck. More often than not, they’ve focused on becoming more productive. There are dozens of methodologies that claim to increase productivity, but there’s a clear winner amongst highly productive software developers: Getting Things Done (GTD). GTD, originally described in productivity guru David Allen’s bestseller of the same title, describes a set of behaviors that, when followed regularly, reduce stress and help you become more productive at the same time. This session looks at how programmers, architects, and technical managers can apply GTD principles to improve the productivity of individuals and the group as a whole. In addition to discussing the core principles of GTD, this session also examines tools that can be used to implement the methodology as well as similarities to agile software development practices.

Outline

The Problem: too much stuff
GTD Overview
Applying what works
GTD in teams
Tools
Summary

Close

Arthur Doler

---

Your thoughts and your emotions affect your work, no matter how much you pretend that you can leave them at the door of your workplace. It's easy to deny your own experience the importance it deserves, especially if it's only inside your own head. But boxing it all away because you have "work to do" is like trying to run a marathon while carrying a Labrador Retriever.

It doesn't have to be that way. This talk will teach you how to frame your world using experiential language rather than clinical language, giving you a powerful tool to discuss your mental health in a way that can be easily felt and understood - and that won't get you in trouble with HR. That sharing becomes the key that unlocks the true power of your team... so come find out how to finally bring your whole self to work!

Close

Arthur Doler

---

Software is as close as humans are ever going to come to actual magic. You type arcane incantations using cryptic symbols, crafting messages incomprehensible to most mortals and communicating them to vast, unknowable systems, to be executed blindly by idiot machine gods who follow our instructions to the very character. We're an elite class of human, chosen through intense courses of secluded study, or simply by the winds of chance, to engage with this symbolic and mystic realm. But while we're comparing ourselves to wizards, witches, and sorcerers, we're actually leaving one of their most powerful tools on the table: rituals.

Let's learn what our brain does when we do an activity repeatedly, with other humans, or simply by ourselves. You'll learn the difference between a ritual and a routine, you'll discover why ritual practices are an important part of being a group, and you'll get an overview of when, where, and how to employ these powerful tools. You'll complete your magical arsenal, and you'll never look at a retrospective the same way again.

Close

Glenn Renfro, Nathaniel Schutta

---

Over the last year we have seen significant changes in the developer world, from the reduction in development budgets to the introduction of AI tooling; proactive developers are adapting to the conditions on the ground exploring additional options to advance their career. What’s a busy developer to do? Being a software engineer is not limited to the act of writing code, there are a veritable plethora of options available to you. In this talk we’ll shatter some of the misconceptions that may have prevented you from trying something new and exciting. You will learn about the wide variety of roles within software, strategies to transition into another aspect of the technical field as well as gain practical advice on when to accept a new opportunity and when to stand pat.
As the market evolves and your preferences change, adding that new line to your resume can provide you that competitive edge. Join us as we uncover the diverse opportunities as well as practical steps to successfully pivot and thrive in a dynamic, ever-evolving industry. Technology changes constantly, your career can’t afford to be a static thing.

Close