Speaker Jordan Miller Abstract We will demonstrate value of your database being a value— it's immutable, it's composable, and time aware. Dive into Datomic’s value-oriented architecture, designed to empower programmers to tackle complexity and build robust systems. Enabling the largest independent bank in the world to run 3000+ Datomic databases, 4000 microservices, and process over 70 billion Kafka events/day. We help 100M+ daily users—all built by ~3000 engineers using Clojure on the JVM and Datomic as a database. https://www.devbcn.com

Speaker Jesus Espino Abstract For years, I have been exploring the source code of projects like the Go runtime and compiler, navigating its intricacies, and uncovering its internal workings. Recently, I have started leveraging AI to accelerate and enhance this exploration. This talk will showcase my experience using AI-assisted tools to analyze and interpret the Go runtime and compiler source code. Attendees will learn how AI can help demystify complex code, provide intuitive explanations, and generate visual representations to accelerate understanding. This session will be valuable for any engineer eager to harness AI for source code analysis. In this talk, I will present my experience using aider, an AI tool, to analyze and interpret Go’s internals more effectively. I will cover the following key topics: Challenges in understanding the Go runtime and compiler: Why traditional approaches can be slow and difficult. Using AI for code analysis: How AI tools can assist in breaking down complex structures and generating explanations. Visualizing internals with AI: Creating diagrams to better grasp execution flows and data structures. Interrogating the codebase with AI: Using AI-driven queries to extract meaningful insights. Lessons learned and best practices: Practical strategies for leveraging AI in software research. Attendees will leave with actionable techniques to explore large-scale codebases using AI tools. This talk aims to inspire developers to embrace AI in their workflow, making it easier to navigate and understand intricate codebases. https://www.devbcn.com

Speaker Gabriele Brambilla Abstract Dow Jones has developed a content recommendation system leveraging Natural Language Processing (NLP) to understand the subtle connections between the vast array of articles it publishes (e.g. from the Wall Street Journal) and the diverse interests of its user base. This presentation will delve into the specific NLP methodologies employed to achieve this nuanced understanding. We will explore the models used to extract semantic meaning from textual content, enabling the system to go beyond simple keyword matching and identify conceptually related articles. Furthermore, the presentation will address a common challenge in recommendation systems: the tendency towards homogeneity and a lack of novel suggestions. We will detail our approach to mitigate this issue by strategically combining data-driven techniques with informed editorial oversight. This balanced strategy ensures that while user preferences are accurately reflected, it also introduces users to a broader spectrum of relevant and potentially surprising content, fostering discovery and exploration. Finally, we will provide a comprehensive overview of the lean and efficient data pipeline we have built to support these advanced recommendation techniques. This will include a discussion of the various data sources that are collected, processed, and integrated into the system. The presentation will conclude with evidence of the system's effectiveness, demonstrating the significant positive impact on user engagement metrics resulting from this enhanced semantic understanding and more diverse recommendation strategy. Attendees will gain valuable insights into building and deploying an efficient NLP-driven content recommendation system successfully balancing tradeoffs to improve user experience and drive engagement. https://www.devbcn.com

Speaker Laurent Doguin Abstract Couchbase started its life as a merge of two open source projects: CouchDB and Membase. This gave us a distributed key/value store with support for map/reduce querying if the value was a JSON document. As many open source projects it has evolved quite a bit in 14 years. We have added support for new data models, new query capabilities or ways of replicating data from cloud to cloud or to the edge. In this 20 minutes we will chronologically go through some of its features, see how sometimes they replaced old ones, or how they enabled new use cases. https://www.devbcn.com

Speaker Isra Chahrazed Abstract Why do we see fewer women in tech, and how can we change this? This talk explores the journey of women in STEM, from young girls fascinated by science and technology to building successful IT careers. We will discuss the barriers women face, such as cultural stereotypes and lack of support, that cause the "leaking bucket" effect where women leave the tech pipeline at various stages. Through real-life stories and data, we'll highlight the unique contributions women bring to the tech industry and the importance of their presence. Most importantly, we’ll explore actionable strategies to support and retain women in tech, including mentorship programs, inclusive workplace policies, and community initiatives. Understand the what, why, and how of empowering women in tech and learn how we can all play a part in fixing the leaks in the bucket, ensuring more women not only enter but thrive in the world of IT. https://www.devbcn.com

Speaker Milen Dyankov Abstract AI is undeniably a buzzword, but it is here to stay. What does this mean for Java developers? Can we design and build applications that harness the power of AI? Most importantly, where do we start? This session focuses on inference—using pre-trained models directly from your code. Instead of relying on proprietary APIs, it'll demystify the "magic" by breaking the AI buzzword down into familiar concepts and components. This will enable you to use AI models as naturally as you would work with databases or workflows. Through live demos, you'll learn to leverage basic embedding models, explore vector databases, and use tools like LangChain4J. By the end, you'll have a practical roadmap to kickstart your journey into Java-powered AI. https://www.devbcn.com

Speaker Richard Brough Abstract At Blue Beck, we were the first to publish re-aligned versions of DeepSeek’s R1 on Hugging Face, aligning the R1-Distil models with Meta’s Llama 3.x. Since then Perplexity AI have courted controversy upon the release of their R1-1776 model with statements about censorship in the original DeepSeek R1. This talk will focus on what it takes to re-align a language model to have a different bias to the original, without losing its capabilities, which is highly relevant in the polarised political environment while rapid advances in language models are occurring. There is a commonly held belief that whoever controls the models also controls the political bias of the output, and while that may hold true for proprietary APIs such as GPT4o & Claude, the emergence of powerful open source models that can be have their bias shifted with a relatively modest amount of compute upends that somewhat. The talk will look at some of the variants of open source models that have appeared, from the academic experiments with RightWingGPT and LeftWingGPT to some of the more disturbing examples that really highlight the risks. https://www.devbcn.com

YouTube video by DevBcn: The Barcelona Developers Conference

Speaker Luis Majano Abstract BoxLang is a new modern dynamic JVM language that can be deployed on multiple runtimes: operating system (Windows/Mac/*nix/Embedded), web server, lambda, iOS, android, web assembly, and more. BoxLang combines features from different programming languages, including Java, CFML, Python, Ruby, Go, and PHP, to provide developers with a modern, functional, and expressive syntax. Interoperability at its Core With 100% interoperability with Java, BoxLang seamlessly bridges the gap between traditional and modern development paradigms, unlocking new possibilities for innovation and collaboration. Framework Capabilities BoxLang is a language and a development framework with a single purpose: to make you productive. It provides out-of-the-box features like scheduled tasks, in-memory applications, event-driven programming, async computing, scripting, queues, modules, and more. Scripting BoxLang has also been designed as a scripting language for any OS. No more convoluted bash or shell scripts. Script in a dynamic language that can be Operating System and Shell agnostic. Multi-Language We have also created the capability to load other language runtimes as modules so you can leverage Python, PHP, JavaScript, Groovy code that can execute within the BoxLang runtime. https://www.devbcn.com

Speaker Karina Gibert Abstract The recent advances on generative AI are changing very rapidly not only the innovation flows and technological society but the software development paradigm itself The talk addresses the reason of this boom in AI, the impacts and the risks and also provides insights on how the ethics from design can avoid some risks and vulnerabilities https://www.devbcn.com

Speaker Barbara Teruggi Abstract Threat modeling isn’t exactly a new concept, but it has recently become a must-have in product design. With cybersecurity threats on the rise and the pressure to deliver faster, security often ends up on the back burner—usually discovered during QA or, worse, after the code is already out the door. At that point, it’s either a headless-chicken chase to fix things or a recipe for disaster. Developers are the ones who really know how applications are supposed to work, so security needs to be part of the conversation from the start. Yet, for some reason, threat modeling is still seen as a "cybersecurity expert-only" club. In this talk, I’ll walk through the threat modeling process, highlight key risk concepts, and show how we can all work together to avoid those "oops" moments. Because, honestly, building secure applications is way more fun when we’re all in it together! https://www.devbcn.com

Speaker Philip Miglinci Abstract Distributing software across on-premises, air-gapped systems, and bring-your-own-cloud (BYOC) setups presents unique challenges. During this talk Philip will share his experiences and learnings from helping companies distribute their software from binaries to Helm charts. For each of the following chapters we will dive into live examples showcasing common errors and proposing fixes that we will be immediately applied and tested. - Packaging Strategies: Semantic versioning, build automation, and dependency management. - Secure Artifact Distribution: Using OCI registries to restrict image tag access, attach SBOMs and regularly scan for CVEs. - Pre-Flight and Target Assessments: Preparing for complex environments with configuration validation and air-gapped packaging. - Deployment Methods: Comparing binaries, Docker images, Helm charts, and BYOC models. - Security and Application Boundaries: Securing Kubernetes deployments with namespaced vs. cluster-scoped installations. - Lifecycle Management: Updating installations, managing licenses, and communicating with teams. We also plan to have enough time for Q&A so we can address real-world deployment challenges from the audience live on stage. https://www.devbcn.com

Speaker Alvaro Sanchez Abstract Annotations, introduced in Java 5 two decades ago, have revolutionised how we develop Java applications. Traditional frameworks like Spring and Hibernate rely on runtime annotation processing using reflection to perform tasks such as dependency injection or implement persistence operations. Alternatively, the Java Annotation Processing API, introduced in Java 6 in 2006, allows developers to hook into the compilation phase to process sources and react to annotations present on them. This was leveraged by libraries like Lombok and Dagger, and frameworks such as Micronaut, although their way of processing annotations varies. Other frameworks like Quarkus perform the annotation processing during build time, instead of the compilation time. In this session, Micronaut Framework committer Álvaro Sánchez-Mariscal will explain with examples the different techniques that can be used for both runtime and compile-time processing of annotations, revealing the magic behind popular open-source projects. https://www.devbcn.com

Speaker Mario Macias Abstract eBPF allows to safely attach small programs in the Linux Kernel and inspect the runtime memory of the Kernel and userspace programs at runtime. This opens a wide range of possibilities for observability applications. However, the low-level approach of eBPF often difficults matching the inspected data with high-level concepts, such as the entities in your Kubernetes cluster. This talk describes our journey to make Kubernetes a first-class citizen in Grafana Beyla, an eBPF-based instrumentation tool that can run as a simple operating-system process but lets its users to keep talking about Pods, Deployments and Services. From a hacker perspective, we will describe how we did to match the low-level abstractions from eBPF with the high-level Kubernetes information, in order to provide a unified experience by fuzzing the barriers between application, platform and infrastructure. https://www.devbcn.com

Speaker Iveri Prangishvili&Jose Correa Abstract Ever wondered how Adobe handles daily infrastructure code deployments across more than 15,000 Kubernetes namespaces that power Adobe Experience Manager? In this session, we'll share how we increased deployment frequency, improved our DORA metrics, cut down engineers' waiting times, and sped up service recovery when things go wrong. We'll walk you through the strategies that helped us streamline deployments and enable fast, reliable code delivery at scale. By combining SlackOps with GitOps, we significantly boosted efficiency. Join us as we dive into CNCF-hosted tools like Prometheus and FluxCD, which we use to monitor and manage rollouts in real time, giving us insights into deployment health and performance. Finally, we’ll explore how we measure and improve key software delivery metrics, showing how these improvements enhance team efficiency and the overall developer experience. https://www.devbcn.com

Speaker Cedric Clyburn Abstract 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. Podman and Podman Desktop bridges this gap. 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 by leveraging Podman and Podman Desktop's perks and security advantages. You'll also learn how you can benefit from Podman Desktop to streamline your container development processes! https://www.devbcn.com

Speaker George Malamidis Abstract January 2024 saw loveholidays' busiest period to date, with loveholidays.com serving 8,050 requests per second. Not only were our systems stable during this time, they also maintained strict performance expectations at a record low infrastructure cost. This is the result of continued focus on performance and scalability. Key has been ensuring our systems undergo daily load testing to address any changes that degrade performance ahead of time. This talk covers the design and implementation of the system we created to automate this, including open sourcing one of the underlying tools written in Go (https://github.com/loveholidays/ripley) and about how replaying real production traffic at multiples of the recorded rate offers insight into how our systems operate at scale. https://www.devbcn.com

Speaker Anshika Koul Abstract Do you have a complex business rule-set problem? You know the kind where you have business rules (logic) spread across multiple platforms, systems and applications? Some of them might even be alter egos of the same rule hiding in different apps. You never know which one might turn up where, there is no single source of truth, solving errors takes hours of debugging, and making changes requires (oftentimes) painful coordination across teams and applications (ugh). We faced this exact challenge at Posten Bring As - Norwegian National Postal Service founded way back in 1647 - a 378-year-old institution with software spanning more generations than most families! Our business logic was scattered across multiple platforms, some almost as old as the company itself (well, not quite, but it sure felt like it). In my session I’m spilling the tea. We discover how the team at century-old Norwegian postal services giant tackled modern challenges with cutting-edge technology. We’ll look through real-world use cases at Posten Bring. We’ll reflect on what we did - key learnings, what went well & most importantly - what didn’t quite go as planned. We'll learn how KMP provides a unified framework for code sharing and execution across various platforms to solve the challenge of different codebases targeting different runtimes. This talk is for you if troublesome & unruly business logic keeps you up at night & you want that to end NOW. It is also for you if you like to hear a good story. https://www.devbcn.com

Speaker Alexandre Touret Abstract Are you facing the challenge of mentoring and developing the skills of young developers? As a lead or experienced developer, you are often called upon to provide technical guidance to new talent. But what approach should you adopt to ensure their optimal progress? For several years, I have been involved in various mentoring and coaching initiatives for young developers. I would like to share with you the best practices I have implemented, as well as the pitfalls I have encountered. By the end of this presentation, we will know how to integrate and empower newcomers as effectively as possible. https://www.devbcn.com

Speaker Aleix Morgadas Abstract Measuring Platform impact is challenging, non-obvious, and involves custom solutions when we go beyond DORA metrics, and yet critical to prove the value it delivers to the whole organization. Inspired in Team Topologies approach, we see how Team Cognitive Load can be used as proxy metric to measure platform impact at technical and human level. In this session, we will see a real world example of how team cognitive load drove the creation of a platform team, and how its impact was measured and scaled within the organization. https://www.devbcn.com

Speaker Mauricio Salatino Abstract Let's face it: we have slowed down developers with a myriad of tools that keep getting more and more complex. In this session, we will look at the state of developer experiences in 2025. We will look at key tools that have enabled developers over the last decade, such as containers (Docker), frameworks (Spring Boot / Quarkus and the Go ecosystem), and complex tools like Kubernetes and how these tools have introduced a lot of friction points for developers. From there, we will explore a path forward to achieve smoother experiences that reduce developers' cognitive overhead. Join me on this session to learn how to improve your developer experiences moving forward and to understand current challenges that development teams are currently facing in the cloud native ecosystem. https://www.devbcn.com

Speaker Victor Rentea Abstract An entertaining review of the most common mistakes in designing an API, from the most outrageous goofs to the most dangerous "innocent" shortcuts. You'll see examples of: Breaking Changes, Domain Model Leak, Sensitive Data Exposure, Performance Issues, Endpoint Coupling, CRUD vs CQRS, PUT overload, Religious REST Fallacy, and Improper Error Handling. Collected with love from over 150 companies. https://www.devbcn.com

Speaker Alina Yurenko Abstract Many people know GraalVM for its performance and resource efficiency. One of the questions that often remains is what applications one can build with it in practice. While serverless and microservices applications are an obvious first choice, there’s so much more. You can build quick and compact CLI applications, that are also very fast to respond. You can build an entire full-stack application, with the backend combining the power of the Java and platform and performance of GraalVM. You can even build an LLM inference engine in pure Java and make it very fast with GraalVM’s ahead-of-time optimizations. In this hands-on session we’ll go through all of those categories of apps and more, as well as tips, recommended practices, and gotchas. https://www.devbcn.com