devnexus.ics

BEGIN:VCALENDAR
PRODID:-//Justin Lee//Devnexus 2023//EN
NAME:Devnexus 2023
VERSION:1.1
CALSCALE:GREGORIAN
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230404T090000
DTEND:20230404T103000
SUMMARY:Hands-on Workshop: Building Streaming Data Pipelines with Apache 
 Kafka
LOCATION:303 (JakartaEE)
DESCRIPTION:Data is everywhere. It's being produced by almost everything 
 around you. In order for businesses to be competitive\, they need to bui
 ld resilient\, scalable systems that can efficiently tap into and react 
 to this ever-increasing volume of data. \n\nEnter: streaming data pipeli
 nes. Apache Kafka is a distributed event streaming platform that allows 
 you to move and transform data in real-time. Throughout this workshop\, 
 you’ll build up a solid foundation and understanding of Kafka\, learning
  the basic building blocks of the technology\, its components\, as well 
 as how to produce and consume data. From there\, you’ll get hands-on exp
 erience ingesting data from external systems into Kafka using Kafka Conn
 ect\, joining and transforming Kafka data in real-time with ksqlDB strea
 m processing\, and using Kafka Connect to move data to downstream system
 s.\n\nBy the end of the workshop\, you'll understand the value of real-t
 ime data and have everything you need to start building your own streami
 ng data pipeline.\n\nNote: This workshop will utilize a free Confluent C
 loud account for hosting Kafka clusters\, stream processing\, and schema
  registry. Participants require some programming knowledge.\n\nSpeakers:
 \n - Danica Fine\n - Amanda Gilbert
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230404T090000
DTEND:20230404T103000
SUMMARY:Hands on with Azure Spring Apps Enterprise
LOCATION:304 (Web)
DESCRIPTION:Azure Spring Apps Enterprise is a fully managed service for S
 pring applications from Microsoft and VMware.  \nBuilding on the Spring 
 framework and bringing the best components of Microsoft Azure and VMware
  Tanzu\, Azure Spring Apps - Enterprise paves the way for a faster path 
 to production\, for every enterprise Spring developer out there. \nAt ou
 r workshop\, get hands on and learn about this amazing solution from Mic
 rosoft and VMware experts. \nLearn how Azure Spring Apps Enterprise can 
 work for your organization. During this session\, we will explore: \nApp
  architectures in the cloud\, and how this managed service enables them.
 \nGo JAR to URL. Take apps to the happiest place on earth — production —
  with the Azure Spring Apps\, without worrying about infrastructure\, ap
 p lifecycle\, monitoring\, etc. Make your apps production ready with pol
 yglot multi-service capabilities\, SSO\, rate-limiting\, and more.\nLear
 n how Azure supports service discovery\, centralized configuration\, ser
 vice connectors\, application auto scaling and monitoring\, distributed 
 tracing\, secrets using Managed Identities and Key Vault\, isolation\, o
 n-premises connectivity\, and blue/green deployment.\nGet insights from 
 our experience in helping customers solve real challenges with typical a
 pp architectures and complexities. As a bonus\, learn all about what mak
 es for a great developer experience.\nTake advantage of our free rapid a
 pp assessment workshop with our experts\, to power your modernization jo
 urney to the cloud. We will have limited slots\, so sign up early! \nPre
 -requisites: \nAttendees should bring a laptop that does not have VPN re
 strictions\, to fully leverage our dev and test environments without cha
 llenges.\nSome professional software development experience\, with worki
 ng knowledge of Spring Boot.\n\n\nSpeakers:\n - Eric Manley\n - Anish Pa
 tel\n - Ajai Peddapanga\n - Manoj Singh\n - John Lafata
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230404T090000
DTEND:20230404T103000
SUMMARY:Creating Evolutionary Architecture and Design: From Problem to So
 lution by exploring patterns
LOCATION:312 (Unobtanium)
DESCRIPTION:Architecture is not a static representation of a system. Ther
 e are several complexities and risks involved in creating them. One way 
 to mitigate the risk is to evolve the architecture. But\, there are risk
 s of evolving as much as there are the risks of not evolving. In this in
 teractive workshop we will explore a set of practices that we can use to
  mitigate the risks. Then we will dive into discussing some common and p
 opular architectural patterns.\n\nFinally\, we will take some example ap
 plications and discuss how to evolve architecture to meet the needs of t
 hose applications.\n\nSpeakers:\n - Venkat Subramaniam
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230404T090000
DTEND:20230404T103000
SUMMARY:Thriving in the cloud: Venturing beyond the 12 factors
LOCATION:313 (Cloud Tech)
DESCRIPTION:Enabling applications to really thrive (and not just survive)
  in cloud environments can be challenging. The original 12 factor app me
 thodology helped to lay out some of the key characteristics needed for c
 loud-native applications... but... as our cloud infrastructure and tooli
 ng has progressed\, so too have these factors. In this workshop we'll di
 ve into the extended and updated 15 factors needed to build cloud native
  applications that are able to thrive in this environment\, and get hand
 s-on with open source technologies and tools (including MicroProfile\, J
 akarta EE\, Open Liberty\, OpenJ9\, and more!) that can help us achieve 
 this.\n\nSpeakers:\n - Rich Hagarty\n - Emily Jiang\n - Cindy High\n - H
 arry Hoots III
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230404T090000
DTEND:20230404T103000
SUMMARY:Spring Boot 3 Workshop
LOCATION:314 (Frameworks)
DESCRIPTION:Spring Boot 3 is the new major revision of Spring Boot. In th
 is workshop\, you will learn the fundamentals of the new features availa
 ble in the Spring portfolio and also application observability mainly wi
 th Micrometer. We will cover the latest developments in Spring Framework
  6\, Spring Boot 3\, and Micrometer. You will apply these fundamentals t
 o realistic scenarios in sample applications where having observability 
 is crucial. You will learn how to Migrate from Boot 2.x to 3\, how to us
 e the new AOT and GraalVM native-image support\, how to effectively hand
 le errors\, how to integrate applications over HTTP via the new Interfac
 e Clients\, how to avoid common issues\, how to make these apps observab
 le\, what observability signals to watch\, and how to integrate metrics 
 with distributed tracing and logs.\nThis workshop is for people who want
  to learn about Spring Boot 3\, Spring Framework 6 and observability. Wh
 at new tools to use and how to use them with the applications they write
  so that they can face the cruel world of production.\n\nPrerequisites:\
 n- Very basic Spring Boot knowledge (how to create beans and HTTP endpoi
 nts)\, you can learn these from our online guides quickly\, e.g.: https:
 //spring.io/guides/gs/rest-service/\n- Java 17 (or higher) installed\n- 
 A Java IDE\n\nSpeakers:\n - Jonatan Ivanov\n - Phillip Webb
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230404T073000
DTEND:20230404T090000
SUMMARY:Workshop Registration & Breakfast
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T090000
DTEND:20230405T100000
SUMMARY:KEYNOTE Five skills to force multiply your technical talent
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Technical skills can be acquired by a wide variety of means s
 uch as getting a degree\, earning a certification\, or reading a tutoria
 l. They are not sufficient\, however\, to be successful in a globally di
 stributed and diverse world. Non-technical skills\, aka soft skills\, ar
 e the personal qualities that define how you interact with others. In a 
 globally distributed and diverse world\, soft skills are sometimes more 
 critical and important than technical skills. These skills are needed wh
 ether you are a newbie or a veteran in the tech industry\, an individual
  contributor or a manager. They help you to be an effective team player\
 , inspire others in the team\, and help make your team more successful. 
 This talk explains five soft skills of communication\, adaptability\, co
 nflict resolution\, mindfulness\, and kindness that help force multiple 
 your team technical teams. You’ll learn how to master these skills to cr
 eate an effective team environment and force multiple your technical tal
 ent. \n\nSpeakers:\n - Arun Gupta
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Software architecture in a DevOps world
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Most modern software teams strive for Continuous Delivery of 
 business impact with a DevOps mindset: you build it\, you run it. With s
 hort iterations and continuous feedback loops\, teams deploy new softwar
 e to production daily.\nBut how about the role of a software architect i
 n such a fast-paced world? With daily deployments\, is there even time f
 or software architecture? As an architect\, how do you prevent being a d
 elaying factor to the pace and success of a team? And how do you keep up
 ?\n\nIn this session\, I'll share my experiences as a software architect
  in the DevOps world. I'll talk about \"just enough\" architecture and m
 oving from up front design to evolving architecture.\nAfter this session
 \, you'll have practical insights and tips in how to work as an architec
 t with a DevOps team.\n\nSpeakers:\n - Bert Jan Schrijver
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Scaling Batch Applications 
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:This talk will discuss how to scale batch applications using 
 Spring Batch. Batch processing is a common requirement for many enterpri
 se applications\, but processing time can become a bottleneck as data vo
 lumes grow. Spring Batch provides a powerful framework for building and 
 running batch applications that can be easily scaled. We will cover topi
 cs such as partitioning\, parallel processing\, and remote chunking\, wh
 ich can help increase throughput and reduce processing time. Additionall
 y\, we will explore best practices for designing batch jobs and using Sp
 ring Batch features effectively. By the end of the talk\, attendees will
  have a solid understanding of using Spring Batch to scale their batch p
 rocessing applications and easily handle large data volumes.\n\nSpeakers
 :\n - Rodrigo Graciano
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Beginners guide to balance your data across Apache Kafka partitio
 ns
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Apache Kafka is a distributed system. At the heart of Apache 
 Kafka is a set of brokers\, which allow to store the records persistentl
 y across different topics. Topics\, in turn\, are split into partitions.
  Dividing topics into such pieces allows us to use data from multiple pa
 rtitions in parallel\, so that producers and consumers can work with dat
 a simultaneously and achieve higher data throughput.\n\nSuch paralleliza
 tion is the key to a performant cluster\, however it comes with a price.
  The thing is\, reading from multiple partitions will eventually mess up
  the order of records\, meaning  that the resulting order will be differ
 ent from when the data was pushed into the cluster. \n\nThis happens bec
 ause when consuming data from multiple partitions\, the order of partiti
 ons is not guaranteed. Instead\, we must rely on the order of the record
 s within a single partition\, where the data is guaranteed to maintain t
 he original sequence. We need to use this characteristic of Apache Kafka
  to our advantage in those cases where the ordering of the records is im
 portant for our system.\n\nTherefore\, when building our product archite
 cture we should carefully weigh up how we will balance records across pa
 rtitions and what mechanisms we will use to ensure that the sequence of 
 the messages remains correct when data is read by multiple consumers. An
 d even more importantly\, how to achieve this and still maintain good pe
 rformance.\n\nIn this talk we'll discuss mechanisms you can use to balan
 ce your data\, such as keys and custom partitioners\, but also practices
  that will help you to balance data evenly and produce and consume data 
 efficiently.\n\nIf you are fresh to Apache Kafka\, or you're looking for
  good practices to design your partitions and avoid common pitfalls\, yo
 u'll find this session useful!\n\nSpeakers:\n - Olena Kutsenko
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Don’t Reimplement Distributed Consensus Algorithms! (Learn to Use
  Them Instead)
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Scaling your services is easy when your services are stateles
 s. However\, in real life applications have to deal with state - how do 
 you scale stateful software systems and their data? This is where it may
  become scary - while modern storage solutions (from Etcd to Cassandra) 
 promise to solve this problem for us\, operating these solutions may be 
 tricky. Even if you don’t have to reimplement underlying consensus algor
 ithms (like Paxos and Raft)\, you still need to understand how they work
  to operate\, debug\, and scale your systems. \n\nThis talk explains the
  mechanics of different consensus algorithms in everyday terms. This tal
 k is not an academic paper: instead of providing formal proofs and scien
 tific language\, it focuses on practical aspects of consensus algorithms
 ’ usage. It explains actionable insights in (relatively) simple words wi
 thout pitching a concrete approach or technology as a magic cure.\n\nSpe
 akers:\n - Alex Borysov\n - Mykyta Protsenko\n - Vadym Khodak
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Machine Learning Data Pipelines with Kafka and Tensorflow
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:An intense presentation designed to operationalize machine le
 arning. This talk focuses on dividing specializations\; data engineer an
 d data scientist. \n\nThe data engineer ensures that data is delivered\,
  manipulated\, and harnessed. The data engineer does this to be useful f
 or the data scientist. The data engineer is also versant in Java and Sca
 la and will be knowledgeable in pub-subs like Kafka.\n\nThe data scienti
 st uses that data\, does their cleaning\, and investigates possible patt
 erns designing a machine learning model that we can use to either find r
 egressions or classifications for our data. The data scientists use Pyth
 on\, Jupyter Notebooks\, Tensorflow\, and Matplotlib as their tools of c
 hoice for constructing a machine-learning model to make decisions about 
 the data.\n\nThis presentation answers the question. How do we take that
  model and tie it to everything else? This workshop will use a wide arra
 y of technologies. It will set you on the path to running Machine Learni
 ng Pipelines in Kubernetes using Kafka and Tensorflow\, so you can start
  immediately when you return to work.\n\nSpeakers:\n - Daniel Hinojosa
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Learn Kubernetes the Java way
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Are you a Java developer making the first steps with cloud ba
 sed technologies? Is learning Kubernetes the hard way a bit too... hard?
  \nWorry not! In this session\, we'll go over the fundamentals of k8s to
  make your journey into using it simpler and more enjoyable. \n\nIn a tr
 ue Java fashion we'll start with a Factory... kidding! with a test-drive
 n exploration of what k8s is\, its concepts and capabilities and learn w
 hy it's such a powerful tool.\n\nWe'll write tests that spin real k8s cl
 usters with Testcontainers\, explore what happens inside\, break the ass
 umptions\, and truly get that first hands-on experience that'll make you
  both confident and a bit dangerous at working with this 10-letter stapl
 e of the clouds.\n\nPS. there will be yaml\, but as little as possible\,
  pinky promise!\n\nSpeakers:\n - Oleg Šelajev
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Secrets of Performance Tuning Java on Kubernetes
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Initially\, getting Java to run on Kubernetes may seem compli
 cated\, but after a few lines of YAML and a bit of work with Docker\, yo
 u will wonder what all that fuss was. It is easy! Then you start looking
  at the performance of your Java app in one core\, one GB of memory cont
 ainer\, and this is when it all very quickly gets murky. Ops\, SREs\, an
 d Java developers need to be aware of the JVM's inner works when decidin
 g on how to resource their applications. Without this knowledge\, it isn
 't easy to know whether it is best to scale vertically or horizontally f
 or performance and costs. This talk will explore JVM ergonomics\, CPU th
 rottling\, Garbage Collectors\, and how using this knowledge can help yo
 u increase performance while reducing costs in the cloud.\n\nSpeakers:\n
  - Bruno Borges
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Getting started with Azure Spring Apps
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Azure Spring Apps makes it easy to deploy Spring Boot applica
 tions to Azure without any code changes. The service manages the infrast
 ructure of Spring applications so developers can focus on their code. Af
 ter this session\, attendees should be able to:\n* Efficiently migrate e
 xisting Spring apps\n* Modernize apps with Spring Cloud patterns\n* Deve
 lop and deploy rapidly without containerization dependencies\n\nSpeakers
 :\n - Jared Rhodes
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:The Right Number of Partitions for a Kafka Topic
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Every technology has that key concept that people struggle to
  understand. With databases\, is which join clause to use for fetching d
 ata from multiple tables. Containers are tricky when you have to pick a 
 storage type given some persistence requirements. With Apache Kafka\, th
 e winner is how many partitions to set for a topic.\n\nWhy this is impor
 tant? You may ask. Well\, sizing Kafka partitions wrongly affects many a
 spects of the system\, such as storage\, parallelism\, and durability. W
 orse\, it may also affect how much load Kafka can handle. Hence why ofte
 n the decision about how many partitions to set for a topic is handled b
 y Ops teams\, as we see this to be only an infrastructure matter. In rea
 lity\, this is an architectural design decision that affects even the am
 ount of code you write.\n\nThis session will peel off the concept of par
 titions and explain it from the perspective of the Kafka cluster and its
  clients. It will explain the formula people should use to decide how ma
 ny partitions to set for a topic\, and how to spot a poor decision when 
 they see one.\n\nSpeakers:\n - Ricardo Ferreira
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Service Mesh for Java Developers
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Service Mesh is the future of application connectivity. It de
 livers immediate value to any architecture by increasing our application
  traffic's security\, reliability\, and observability. \n\nIt abstracts 
 the underlying network details and provides discovery\, routing\, and a 
 variety of other functionality.\n\nIn this service mesh presentation\, V
 iktor will show you how easy it is to get started (in Kubernetes) - how 
 to install a control plane\, deploy a JVM-based demo application (using 
 popular java frameworks like spring boot\, micronaut\, etc)\, enable tra
 ffic policies\, and touch on observability.\n\nSpeakers:\n - Viktor Gamo
 v
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Jakarta EE or Spring? Real world testimonies
LOCATION:303 (JakartaEE)
DESCRIPTION:You are starting a new project and you need to choose between
  languages and frameworks but you face one of the toughest decisions abo
 ut going with the Spring family or the Jakarta EE ecosystem. \nIn this s
 ession we will discuss how each one can fit in different situations with
  pros and cons and give you tips to help you choose the right tool for t
 he right problem using real world scenarios from our 10+years of experie
 nce developing enterprise applications with java. \n\nSpeakers:\n - Jose
  Diaz\n - Jorge Cajas
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Upgrading a Legacy Java EE App with Style
LOCATION:303 (JakartaEE)
DESCRIPTION:In the span of several weeks\, we took a legacy app that had 
 been running in production for 12 years\, moved it to git\, mavenized it
 \, upgraded from Java 6 to Java 8\, and upgraded from Java EE 5 to Java 
 EE 7. Oh\, and did I mention that it uses SOAP\, JSP\, and JSF 1.2? We d
 id all this with a relatively minor amount of code changes\, thanks to t
 he backward compatibility of Java 8 and Java EE. Come to this session to
  learn how we did it\, what issues we ran into\, which app server we wer
 e using\, and why we didn't move to a newer JDK\, Java EE 8 or Jakarta E
 E.\n\nSpeakers:\n - Kito Mann
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Jakarta EE and MicroProfile Highlights
LOCATION:303 (JakartaEE)
DESCRIPTION:Jakarta EE and MicroProfile are powerful platforms for develo
 ping applications and microservices. Attendees of this session will lear
 n important features of Jakarta EE and MicroProfile through a number of 
 examples\, using a hands on approach\, correlating usage of the APIs to 
 real-life scenarios. The examples presented will showcase both establish
 ed and recently released features of Jakarta EE 10 and MicroProfile 6. T
 he focus will be on some of the most important features from a variety o
 f specifications\, ranging from Jakarta Faces to Jakarta WebSockets and 
 MicroProfile Config. The demo’s provide an overview of each\, including 
 how specifications complement each other. In order to run these examples
 \, we will use server-side resources using Payara\, and development of m
 icroservices with Payara Micro and Docker. \nAttendees will walk away wi
 th a solid understanding of some of the most important features of Jakar
 ta EE and MicroProfile.\n\n\nSpeakers:\n - Josh Juneau\n - Edwin Derks
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Jakarta EE for Spring Developers
LOCATION:303 (JakartaEE)
DESCRIPTION:**Jakarta EE 9** changed its package namespace from `javax.*`
  to `jakarta.*`. This may sound like a trivial change that mostly affect
 s Jakarta EE. So\, why should Spring developers care?\n\nAs it turns out
 \, the namespace changes ripple throughout the entire Java ecosystem. An
 d Spring is no exception. Spring Framework 6 and Spring Boot 3 raise the
 ir baseline to Jakarta EE 9 API level which is supported by Tomcat 10 an
 d Jetty 11 for example.\n\nAttending this session will teach you how to 
 make this migration as smoothly as possible. A live coding demo will tak
 e you through the steps involved\, and point out where to pay special at
 tention.\n\nWe will also briefly examine some of the changes introduced 
 in **Jakarta EE 10** that will prepare you for what to expect from Sprin
 g 6.x. Some pointers to what we can expect from **Jakarta EE 11** will a
 lso be given.\n\nSpeakers:\n - Ivar Grimstad
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Deep Dive MicroProfile 6.0 with Jakarta EE 10 Core Profile
LOCATION:303 (JakartaEE)
DESCRIPTION:Both MicroProfile and Jakarta EE are cloud native API standar
 ds for developing portable microservices. \n\nJakarta EE 10 Core Profile
  was the new profile in Jakarta EE 10. The new shining hot-in-the-press 
 MicroProfile 6.0 has already fully embraced Jakarta EE 10 Core Profile. 
 Apart from this\, MicroProfile 6.0 also provided some major updates from
  MicroProfile Metrics\, which enabled the adoption of Micrometer and Mic
 roProfile Telemetry that consumed OpenTelemetry. Come to this session to
  learn all about the observibility standard for your microservices with 
 a live demo on Open Liberty.\n\n\nSpeakers:\n - Emily Jiang
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Full-stack reactive with Spring Boot & React
LOCATION:304 (Web)
DESCRIPTION:As Java developers\, we know the benefits of type-safety when
  building apps. The problem? Usually\, that type-safety ends when we lea
 ve the server. What if it didn't have to be that way?\n\nIn this present
 ation\, you'll learn how to build a full-stack reactive web app through 
 live code examples. We'll use Spring Boot and Java on the backend and Re
 act with TypeScript on the frontend\, connecting the two with the new Hi
 lla framework from Vaadin.\n\nSpeakers:\n - Marcus Hellberg
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Cross-Platform Cloud CI/CD
LOCATION:304 (Web)
DESCRIPTION:More and more teams are leveraging cross-platform development
  for their web\, mobile PWA\, iOS\, and Android applications. However\, 
 if you are still leveraging traditional CI/CD or manual deployment proce
 sses\, you can still experience release delays and different DX and UX a
 cross platforms. A unified system for cross-platform builds and deploys 
 can prevent knowledge silos\, speed up releases\, and ensure an efficien
 t process no matter what the platform. This talk will cover the consider
 ations when building a CI/CD system to manage web and mobile deployments
 \, and options for implementing a cross-platform CI/CD solution in the c
 loud.\n\nWhat you'll learn:\n- How web\, Android\, and iOS deployments a
 re different\n- The specific factors to consider when building a cross-p
 latform CI/CD strategy\n- Options for implementing a cloud CI/Cd strateg
 y for all your deployments across multiple platforms\n\nSpeakers:\n - Ce
 celia Martinez
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Vue for React Developers
LOCATION:304 (Web)
DESCRIPTION:React is one of the most popular front end frameworks... but 
 within the React community there are several misconceptions about Vue. L
 et's go through and convert a React component into a Vue component. The 
 results might surprise a lot of React developers!\n\nSpeakers:\n - Alex 
 Riviere
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:From Your Perspective
LOCATION:304 (Web)
DESCRIPTION:There are countless practical applications of 3D transforms. 
  Too often 3D is a buzzword for a large\, flashy framework\, and not a s
 impler way to present information.  Behind complex linear algebra is sim
 ple intuition that you already have and can use.  In this presentation\,
  I will review the ideas of matrix transforms without the headache.  Eve
 ryone\, from academic to beginner will have a clearer understanding of t
 he world\, both virtual and real.\n\nIn this talk we review the tiny bit
 s of math that masquerade as magic so that everyone feels like they gain
 ed superpowers.\n\nSpeakers:\n - Gant Laborde
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Properly Managing Data In React
LOCATION:304 (Web)
DESCRIPTION:One of the biggest issues found in any large-scale applicatio
 n is how to properly manage data. in this talk I want to talk about the 
 different ways engineers can build applications with appropriate levels 
 and access.\n\nSpeakers:\n - Jamal Jackson
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Dataframes\, Collections\, and Streams in Java
LOCATION:305 (Core Java)
DESCRIPTION:Wanna go full Data Scientist or Collection Ninja* with Java? 
 We've got your back!\n\nJoin us on our fun adventure of exploring the wo
 rld of dataframes\, collections\, and streams!\n\nWe will be using built
 -in features in Java\, as well as libraries like Eclipse Collections and
  Dataframe-EC.\n\n—--------\n*) Collection Ninja - someone who knows how
  to manipulate collections like wielding a samurai sword\n\n\nSpeakers:\
 n - Rustam Mehmandarov\n - Donald Raab
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Cooking Recipes\, Coding\, an IDE and YOU
LOCATION:305 (Core Java)
DESCRIPTION:Tasks from our everyday lives\, such as cooking\, involve ini
 tiating and accomplishing multiple sub-tasks. Over time\, we usually mas
 ter or improve upon these processes with practice. Let’s apply these two
  concepts\;  a cooking recipe and hands-on coding experience\, to learn 
 more about Java’s Future and CompletableFuture API\, important \"utensil
 s\" to cater to asynchronous or non-blocking needs in Java.\n\nIn this s
 ession\, we’ll walk through centuries old Indian recipe ‘Paneer Tikka Ma
 sala’- a dish cherished by folk across the globe. In the talk\, we’ll dr
 aw a parallel between the challenges of our recipe’s parts which involve
  asynchronicity and non-blocking activities\, and how Java's APIs can ad
 dress them in similar situations in your application code.\n\nLearning t
 hese concepts using Coding Katas\, together we will fix failing code\, h
 ands-on\, and learn how to work with Java’s CompletableFuture. By follow
 ing a trail of TODOs and HINTs in the code\, and an accompanying README\
 , all integrated in the same project\, you’ll experience the code\, rath
 er than just watching a deck\, in an Integrated Development Environment!
 \n\nIf you are a library or an API author\, this talk may inspire you to
  create Code Katas to help others understand and correctly use your libr
 aries/API.\n\nWith this session you’ll learn how to make Paneer Tikka Ma
 sala and while learning new or better ways to use Java asynchronous and 
 non-blocking APIs.\n\nSpeakers:\n - Mala Gupta\n - Chandra Guntur
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Know your Java?
LOCATION:305 (Core Java)
DESCRIPTION:Many of us have significant experience in Java. Yet\, from ti
 me to time\, we get tripped up by some code that we quite did not expect
  to behave the way it does.\n\nIn this presentation we will take a look 
 at some of those and get a deeper understanding of the language we use e
 veryday\n\nSpeakers:\n - Venkat Subramaniam
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:How to Fix Your Technical Debt Dilemma
LOCATION:305 (Core Java)
DESCRIPTION:When you think about 1\,700 developer days (or 4.8 years of t
 ime) in the engineering world\, how does that make you feel? To me\, it 
 feels like infinity. Technical debt can show up like this in an organiza
 tion. It’s a backlog of issues—migrating software\, cleaning up code\, a
 nd fixing security vulnerabilities—that can paralyze engineering organiz
 ations and lead to burnout. And the reality of modern applications is th
 at they naturally accrue tech debt. They are composed of large and diver
 se codebases and ecosystems—a supply chain of custom\, third-party\, and
  open source software. Dependencies are changing frequently and evolve a
 t their own pace. Not updating leads to critical bugs\, performance\, an
 d security issues. The key to fixing your technical debt dilemma is cont
 inuous software modernization. You’ll never get behind when maintenance 
 work that would normally take many months of manual effort can be automa
 ted and completed with a PR in minutes. This is how developers stay ener
 gized and your business can thrive.\n\nIn this talk\, I’ll introduce Ope
 nRewrite\, an open source\, auto-refactoring technology that was born at
  Netflix in 2016. It uses sophisticated\, fast code search capabilities 
 in combination with powerful change recipes that actually fix the code. 
 I’ll share a use case of a common issue remediation—running a recipe liv
 e that fixes the issue and executing it across 300 million lines of open
  source code. The recipe will be made available in open source for you t
 o apply to your own codebase at the end of the session.\n\nKey Take-away
 s:\n\n* Technical debt can be reframed as continuous software modernizat
 ion with robust automation that not only finds the issues\, but fixes th
 em regularly.\n* OpenRewrite uses a similar approach as an IDE to automa
 te refactoring\, but takes it out of single person\, single repo mode\, 
 so it can be delivered in different ways. The refactoring is 100% accura
 te and style preserving.\n* You can see immediate results using the open
  source change recipes from OpenRewrite—just try out one recipe and get 
 days of your time back!\n* Moderne has a Saas platform that works with O
 penRewrite recipes to help you execute continuous software modernization
  at scale—across repositories simultaneously\n\n\nSpeakers:\n - Jonathan
  Schneider
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Refactor your code to Java 20
LOCATION:305 (Core Java)
DESCRIPTION:All of a sudden Java is a hip language again. With every rele
 ase\, we get new features. But your code still looks like 2014 aka Java 
 1.8. Let’s change that and bring the new style to your codebase. In this
  session\, we will take a look at “legacy” code and refactor it to gain 
 the benefits of newer Java versions. In a live coding setting\, Barry an
 d Richard will present each other with refactoring quests to demonstrate
  how you can go about changing your code today.\n\nDisclaimer: You might
  learn about features your colleagues don't want you to know because you
  won’t stop talking about new Java releases 😉\n\n\nSpeakers:\n - Richar
 d Fichtner\n - Barry Burd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:The Anatomy of Java Vulnerabilities
LOCATION:311 (Security)
DESCRIPTION:Java is everywhere. According to Oracle\, it’s on 4 billion d
 evices and counting.\n\nAs we’ve seen with vulnerabilities like Log4Shel
 l\, keeping up to date with patches is critical\, but each time you do\,
  it’s an opportunity to break your code or let a new vulnerability in.\n
 \nHow do you decide what to patch and what to ignore?\n\nIn this talk\, 
 you’ll learn about Java vulnerabilities in general: what a ‘vulnerabilit
 y’ actually is\, how they are discovered\, reported\, managed\, assessed
  and fixed as well as hearing a little about the specifics of attack vec
 tors and bad actors. \n\nUnderstanding how to choose your dependencies m
 ore wisely to reduce your exposure and keep your application working is 
 a skill we all need to grow - start here to begin that journey.\n\n\nSpe
 akers:\n - Theresa Mammarella
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:How to report a vulnerability: Responsible Disclosure for Develop
 ers
LOCATION:311 (Security)
DESCRIPTION:Ever seen a security-related issue that you felt should be re
 ported? Unsure of how reporting security issue is different than a regul
 ar bug? Developers of any level should know how to report a vulnerabilit
 y. In this talk\, we will talk about what CVEs are\, some general vulner
 ability classifications\, look at a few common ways you can report secur
 ity issues\, as well as look at a few common mistakes. This talk is gear
 ed toward non-security professionals.\n\nSpeakers:\n - Brian Demers
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Wargames - Java vulnerabilities and why you should care
LOCATION:311 (Security)
DESCRIPTION:Java is great and we all spend time on making it more perform
 ant\, more scalable and maintainable. But we better should also spend so
 me time on making it more secure. With all that new Java releases and fe
 atures also come new vulnerabilities and exploits. Because Java is every
 where\, it has a huge attack surface which makes it interesting for hack
 ers to search for vulnerabilities in Java and foremost in Java based app
 lications. This sessions will explain what all these mystique acronyms l
 ike NVD\, CVE\, CVSS\, CPU\, PSU etc. mean and how they are related to J
 ava security. It will also be shown what tools are available to you to c
 heck whether your Java application is vulnerable to known issues.\n\nSpe
 akers:\n - Gerrit Grunwald
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Empowering Developers to Embrace Security
LOCATION:311 (Security)
DESCRIPTION:In this talk\, I will show you why it is important to empower
  developers to make secure decisions from the beginning. Good communicat
 ion and collaboration between security and development teams will improv
 e developer adoption. We need to combine a collaborative culture with th
 e right process and the right tooling to enable developers to build thei
 r applications more securely.\n\nSpeakers:\n - Brian Vermeer
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Securing Your Software Supply Chain One Open Source Project at a 
 Time
LOCATION:311 (Security)
DESCRIPTION:Delivering software fast is one piece of the CI/CD puzzle\, b
 ut delivering it securely is the glue that keeps your puzzle from fallin
 g apart. Software supply chain attacks are on the rise with security exp
 loits directly targeting open source projects\, central repositories\, a
 nd software package managers. Now that developers are the target of secu
 rity attackers\, how do you protect your DevOps pipeline?\n\nThis is a p
 roblem that the Continuous Delivery Foundation (CDF)  is working to solv
 e.. To help ensure a secure SDLC\, the CDF is investing in projects that
  provide security solutions and in 2022 announced a new incubating proje
 ct\, Pyrsia. This talk will highlight the importance of securing your so
 ftware supply chain at the source and how Pyrsia is working to solve thi
 s problem.\n\nSpeakers:\n - Lori Lorusso\n - Ixchel Ruiz
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Avoiding common pitfalls with modern microservices testing
LOCATION:312 (Unobtanium)
DESCRIPTION:Have you ever wondered why your microservices break in produc
 tion after all the tests have passed during CI/CD? Have you ever wondere
 d if you’re testing too much or too little? If you want to learn about c
 ommon pitfalls and how to catch them at build time rather than at runtim
 e\, this session is for you!\n\nIn this session\, we’ll share some commo
 n battle scars from our experiences in the field. Additionally\, we will
  introduce the testing pyramid and explain why it is important in helpin
 g to continuously deploy microservices independently without fear. We wi
 ll demonstrate\, through a test-driven development approach\, how the co
 mbination of Pact contract testing combined with Quarkus developer joy c
 an help prevent your microservices from breaking in production\n\nSpeake
 rs:\n - Eric Deandrea\n - Holly Cummins
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Live Coding Quarkus: Supersonic\, Subatomic Kubernetes-Native Jav
 a
LOCATION:312 (Unobtanium)
DESCRIPTION:Quarkus is a Supersonic\, Subatomic Kubernetes-native Java st
 ack built from best of breed libraries and standards.\n\nQuarkus is:\n* 
 Really Fast!\n* Container First\n* Community driven\n* Standards based\n
 * Light weight\n* Built for Testing\n* Imperative and Reactive\n* Perfec
 t for Microservices\n\nMost importantly Quarkus is built for “Developer 
 Joy!”  \n\nCoding with Quarkus is productive and fun. Quarkus delivers a
 n inner development loop that provides instantaneous feedback and an out
 er loop that makes Kubernetes easy (well\, almost easy.)\n\nJoin me as I
  build and deploy a Quarkus application and experience the Developer Joy
  for yourself!  \n\nAt the end of this presentation you will know:\n* Wh
 at Quarkus is and how it works\n* How to get coding quickly \n* How to b
 uild REST applications in minutes\n* How to build event-driven applicati
 ons using Apache Kafka\n* How to deploy applications to Kubernetes\n* Ho
 w to continuously test with real dependencies\n\nOnly 3 slides\; the res
 t is hands on keyboard Developer Joy!\n\n\nSpeakers:\n - Jeremy Davis
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Quarkus for Spring Developers
LOCATION:312 (Unobtanium)
DESCRIPTION:In this session\, I will show concepts and conventions famili
 ar to Spring developers and how those same concepts and conventions can 
 be implemented in Quarkus\, all while highlighting similarities and diff
 erences between them. Additionally\, I will show similarities and differ
 ences in how testing is done\, highlighting Quarkus Dev Services.\n\nThi
 s session will be mostly live coding while minimizing the amount of slid
 es. I will introduce an existing Spring application with a full test sui
 te and build a Quarkus equivalent version of it\, live.\n\nSpeakers:\n -
  Eric Deandrea
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Hyper-Automate your Cloud Native Journey with Kubernetes Custom R
 esources and Operators
LOCATION:312 (Unobtanium)
DESCRIPTION:Kubernetes has become the de-facto orchestration platform tha
 t automates the deployment\, scaling\, and management of containerized m
 icroservices/applications. However\, managing complex applications\, inc
 luding those built for multiple cloud environments\, can be challenging\
 , especially when it comes to tasks such as configuring\, upgrading\, an
 d monitoring.\nKubernetes Operators are a powerful extension to Kubernet
 es that provides a way to automate the management of complex application
 s\, including tedious DevOps and administrative operations. \nOperators 
 are in fact software extensions that can be deployed on a Kubernetes clu
 ster to monitor specific Custom Resources Definitions (CRD) defined by t
 he admins. \nThey will ultimately enable developers to automate routine 
 and repetitive tasks\, simplify application management\, and scale appli
 cations more efficiently.\nMo Haghighi\, Distinguished Engineer at Disco
 ver Financial Services\, will explore the advantages of Kubernetes opera
 tors for boosting developers’ productivity and how enterprises can exped
 ite their modernisation journey and automate their multi-cloud deploymen
 t by adopting operators. \n\nSpeakers:\n - Mo Haghighi
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:KEDA\, HPA\, and VPA? An Introduction to Scaling a Event-Driven W
 orkloads on Kubernetes
LOCATION:312 (Unobtanium)
DESCRIPTION:Scaling modern event-driven applications that use an event-lo
 op\, such as those written using Node.js or Vert.x shouldn't be based on
  a single metric such as CPU usage. Code that uses blocking APIs or perf
 orms CPU-bound operations can have a significant impact on application r
 esponsiveness. Using Worker Threads can help alleviate pressure on the e
 vent-loop\, but scaling out more replicas also plays an important role.\
 n\nJoin this session for a practical introduction to Kubernetes autoscal
 ing\, and KEDA. We'll examine an application that suffers reduced throug
 hput and increased latency due to CPU-bound tasks blocking the event-loo
 p. We'll then explore how Worker Threads and autoscaling features provid
 ed by Kubernetes and KEDA can keep our application both highly-available
  and responsive.\n\nSpeakers:\n - Evan Shortiss
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Observability For Java Devs - 2023 Edition
LOCATION:313 (Cloud Tech)
DESCRIPTION:As applications move to containers and migrate to the cloud\,
  they become ever more complex\, and it's increasingly important to moni
 tor\, analyze\, and diagnose their behaviour. Observability is a new way
  of thinking about monitoring and understanding your applications. It’s 
 supported by a growing range of open source tools and standards - part o
 f the new wave of technologies that modern developers need to go fully C
 loud Native.\n\nJoin Ben Evans to get the state of the fundamentals of O
 bservability in 2023. You'll learn how to achieve observability in Java 
 using OpenTelemetry\, the emerging Open Standard for Observability\, and
  we'll meet several other related OSS libraries and tools (such as Jaege
 r) along the way.\n\nSpeakers:\n - Ben Evans
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Let's get Functional: The fast path to smart serverless with Spri
 ng Cloud Function & Azure Functions
LOCATION:313 (Cloud Tech)
DESCRIPTION:So-called \"serverless\" may be the least accurate tech name 
 in history\, although there are countless worthy contenders for that (di
 s)honor. And while functions may not have a perfectly precise definition
  in terms of size or scope\, we're far more likely to reach general agre
 ement on functions - their purpose\, scope\, pros/cons\, and utility - t
 han we are to ever locate those missing servers. :)\n\nIn this session\,
  the presenter examines what makes a capability or set of capabilities i
 deal candidate(s) for development and deployment as one or more function
 s. The presenter will then lead attendees on a Live Coding Adventure(TM)
  to demonstrate how to create candidate functions using the power of Spr
 ing Boot and Spring Cloud Function. Finally\, we will deploy these open 
 source functions via Azure Functions to demonstrate how to integrate eve
 rything in the cloud and reveal some potentially very welcome discoverie
 s. Come to this session to learn how to incorporate functions into your 
 critical systems. With great power...\n\nSpeakers:\n - Mark Heckler
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Natively Cloud Native - Building Agile Microservices with Microna
 ut
LOCATION:313 (Cloud Tech)
DESCRIPTION:This talk is a fast-paced introduction to the Micronaut frame
 work\, from creating the first app to orchestrating a microservice feder
 ation and deploying to the cloud. We will cover the basics of writing Mi
 cronaut apps\, communication between services\, building for resiliency\
 , managing configuration\, and deploying to a cloud provider. By the tim
 e we’re finished\, you’ll have a good understanding of both the distinct
 ives and features of the framework and be ready to start building and de
 ploying your own apps with Micronaut. Buckle up!\n\nSpeakers:\n - Zachar
 y Klein
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Progressive Delivery with Kubernetes and Argo Rollouts
LOCATION:313 (Cloud Tech)
DESCRIPTION:Progressive Delivery is the process of releasing service upda
 tes in a controlled and gradual manner hence reducing risk. There are mu
 ltiple ways to achieve this if you are using Kubernetes. Join me in this
  session to explore different deployment strategies like rolling updates
 \, blue/green and canary releases. \nFinally\, we'll see canary releases
  in action using Argo Rollouts to automate  promotion and rollback of up
 dates based on metric analyses.\n\nSpeakers:\n - Orlando Valdez
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Weathering the Cloud Storm: Building Resilient Geo-Distributed Ap
 ps with Spring Cloud
LOCATION:313 (Cloud Tech)
DESCRIPTION:Cloud availability zones and regions are not immune to outage
 s. The zones go down regularly and regions become unavailable during nat
 ural disasters or human-caused incidents. Thus\, if an availability zone
  or a larger area goes down\, so does your application—unless the applic
 ation can work across multiple geographic locations.\n\nCome and learn h
 ow to build resilient\, geo-distributed Java apps that can withstand var
 ious cloud failures. Using Spring Cloud tools and components\, you'll ar
 chitect and deploy a geo-distributed Slack-like messenger that can span 
 several continents\, load balance requests across distant regions\, and 
 most importantly\, tolerate various storms and outages in the cloud.\n\n
 Speakers:\n - Denis Magda
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Spring Recipes: A Collection of Common-Sense Solutions
LOCATION:314 (Frameworks)
DESCRIPTION:Over the years\, Spring has evolved to solve the ever-increas
 ing demands placed on software teams. From circuit breakers to security 
 to queues to Kubernetes\, Spring has an answer to that! But breadth can 
 be overwhelming especially when you need to deploy to production yesterd
 ay. While knowing maybe half the battle\, left unsaid is applying that k
 nowledge to real-world situations\; in other words\, how do you bridge t
 he gap between knowing Spring can do that to actually using Spring to fi
 x your issue? With a plethora of examples\, this talk will walk you thro
 ugh common problems in modern software development. From monitoring to t
 esting to messaging to reactive programming\, this talk will give you co
 ncrete solutions for your day-to-day needs.\n\nSpeakers:\n - Nathaniel S
 chutta\n - Dan Vega
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Vector Similarity Search in Spring with Redis Stack
LOCATION:314 (Frameworks)
DESCRIPTION:Vector Similarity Search (VSS) is no longer a feature that li
 ves in AI/ML demos only! VSS has a wide range of applications including 
 eCommerce\, recommendation engines\, chatbots\, image and video search\,
  and chemistry. In this talk\, we'll learn how to implement VSS in Sprin
 g applications using Redis Stack enhanced search capabilities. We'll lea
 rn about creating embeddings for your data\, learn about Vector database
 s\, Vectorization of your data\, similarity metrics\, and more.\n\nSpeak
 ers:\n - Brian Sam-Bodden
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:GraphQL from the Ground Up
LOCATION:314 (Frameworks)
DESCRIPTION:REST has become a standard for services on the internet\, but
  it isn't without its drawbacks. GraphQL is a query language from Facebo
 ok that's caught on to address many of these issues. It provides API con
 sumers with better visibility and more control over their data.\n\nWhere
  REST has endpoints and status codes\, GraphQL has queries\, mutations\,
  types\, and richer errors. It allows you to ask for precisely the data 
 you need\, to batch requests for parallel server processing\, and even r
 eturns partial results in the face of downstream failures.\n\nIn this ta
 lk\, we will explain our experience adopting GraphQL at New Relic. We wi
 ll discuss the challenges and solutions we found - including the smaller
  community using GraphQL outside of the Javascript ecosystem\, how we le
 arned to think differently about the data we expose\, and why you might 
 consider adopting it yourself. We will also showcase the open-source lib
 raries that we created to help both our own services and those of the wi
 der community.\n\nSpeakers:\n - Jason Clark
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Spring Modulith:  What the what?
LOCATION:314 (Frameworks)
DESCRIPTION:When designing software systems\, architects and developers h
 ave plenty of architectural options from which to choose.  Over the last
  few years\, we have seen the growth of Microservice-based systems. Howe
 ver\, the idea of monolithic\, modular systems has recently regained pop
 ularity.  Regardless of which architecture we choose\, how can we build 
 the individual applications that comprise our overall system such that t
 heir structure is evolvable to follow business requirements?\nWhat if I 
 were to tell you there was a way for you to express these logical applic
 ation modules in code so that you can build well-structured\, domain-ali
 gned Spring Boot applications?  Spring Modulith does this by providing t
 he developer a way to declare logical modules in Spring Boot application
 s.  It also provides the tooling needed to write Junit tests that run st
 ructural validation tests\, run integration tests for individual modules
 \, and to document the module arrangement.  It also has features that le
 t you implement module interactions in a loosely coupled way and then le
 ts you observe module interactions between each other at runtime.  In th
 is talk\, we discuss the features that are available and then in a live 
 coding demonstration show you how they work.\n\nSpeakers:\n - Glenn Renf
 ro\n - Felipe Gutierrez
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Bootiful Spring Boot 3
LOCATION:314 (Frameworks)
DESCRIPTION:Spring Boot 3 is here and with it come a whole host of new op
 portunities and possibilities. Join me\, Spring Developer Advocate Josh 
 Long and we'll look at the amazing new features in Spring Boot 3 that ma
 ke it the best choice for cloud native applications\n\nSpeakers:\n - Jos
 h Long
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Java's Hidden Gems: Tools and Libraries
LOCATION:315 (Java Platform)
DESCRIPTION:This session is a whirlwind tour of many lesser known\, but v
 ery interesting\, Java tools and libraries. We'll have a sneak peak at d
 ozens of tools to improve security\, builds\, architecture\, tests and o
 ther areas. After this session you'll surely have learned something new\
 , which you can further investigate whenever you want to apply it.\n\nSp
 eakers:\n - Johan Janssen
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:The Cloud Native Compiler: JIT-as-a-Service
LOCATION:315 (Java Platform)
DESCRIPTION:Adaptive\, just in time (JIT) compilation provides a massive 
 performance improvement to JVM-based applications compared to only using
  an interpreter.  The downside of this is that applications have to comp
 ile frequently used methods as the application is running.  This can lea
 d to reduced throughput and slower response times.  Another drawback is 
 that each time an application is started\, it must perform the same anal
 ysis to identify hot spot methods and compile them.\n\nWhen running an a
 pplication in the cloud\, the elastic nature of resources provides the a
 bility to change and improve the dynamics of how the JIT compiler works.
 \n\nIn this session\, we'll look at Azul's work to move the JIT compiler
  into a centralized service that can be shared by many JVMs.  This provi
 des many advantages\, such as caching compiled code for instant delivery
  when restarting the same application or spinning up new instances of th
 e same service.  In addition\, it removes the workload from individual J
 VMs\, allowing them to deliver more transactions per second of applicati
 on work.  Finally\, there is the opportunity to apply considerably more 
 compute resources to enable complex optimizations to be used that wouldn
 't be practical in a single JVM.\n\n\nSpeakers:\n - Simon Ritter
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Patterns\, Predictions\, and Programming 
LOCATION:315 (Java Platform)
DESCRIPTION:Machine Learning Tools for Java Developers - VisRec\, ChatGPT
 \, etc\n\n\"One of the most interesting aspects of the world is that it 
 can be considered to be made up of patterns\" - Norbert Wiener (1940s). 
   We are entering a new and long-tail phase of software development with
  Machine Learning (ML). ML\, a subset of AI\, is the ability of a machin
 e to produce accurate results for a particular problem without any expli
 cit programming. These predictive results are derived from recognizing p
 atterns in large data sets. We are effectively giving machines the abili
 ty to gain experience.  \n\n\nWith the new generation of “generative AI/
 ML” tools such as ChatGPT\, DALL-E\, Bard\, Stable Diffusion\, et al.\, 
 this megatrend affects our applications\, software tools\, data structur
 es\, systems architecture\, new hardware approaches\, business processes
 \, organizational interactions\, enterprise strategies\, government beha
 vior\, geopolitical strengths\, ethics\, data privacy\, etc. In essence\
 , ML is an inflection point for computing\, enterprises\, countries\, hu
 manity\, and civilization. \n\n\nWe’ll explore some basic ML use cases\,
  take a look at JSR #381 (Visual Recognition for Java)\, dive into the C
 hatGPT API\, show some demos\, and then discuss what all this means for 
 Java developers.\n\nSpeakers:\n - Frank Greco
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Enhancing Java applications for the cloud
LOCATION:315 (Java Platform)
DESCRIPTION:Are you in the process of modernizing your business from a mo
 nolith to an agile micro-service oriented model in the cloud? Or is your
  application already cloud-native? There are different performance conce
 rns that need to be taken into account when deploying to the cloud in co
 mparison to traditional deployments. With serverless and FaaS models\, s
 tartup time and memory footprint play a big role\, as it determines the 
 cost of deploying to the cloud. Come to this session to learn more about
  how technologies like checkpoint/restore and remote JIT compilation can
  help boost startup time and reduce memory footprint to minimize your co
 sts. You'll also learn how these features integrate seamlessly with exis
 ting container technologies for simple\, secure and predictable deployme
 nts. Whether you are a cloud veteran or a new comer\, there will be lots
  to learn!\n\nSpeakers:\n - Tobi Ajila
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Asynchronous Programming in Java using Virtual Threads
LOCATION:315 (Java Platform)
DESCRIPTION:Threads have been part of Java since the beginning. But\, the
  new virtual threads\, introduced as prerelease in Java 19\, are differe
 nt in how they're implemented and how we can benefit from them.\n\nIn th
 is presentation we will learn about virtual threads\, the problems they 
 solve\, and how to make use of them.\n\nSpeakers:\n - Venkat Subramaniam
 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T173000
DTEND:20230405T183000
SUMMARY:The OffHeap Podcast. Devnexus Edition
LOCATION:315 (Java Platform)
DESCRIPTION:We are back at it again! The usual suspects comes back to rec
 ord a live episode of OffHeap. We discuss the latest Java News\, and we'
 ll have a (incredibly amazing\, soon to be found) guest... Like other se
 ssions we'll have trivia and a great time. Come take a listen to our liv
 e episode\, participate and have fun! \njavaoffheap.com\n\nSpeakers:\n -
  Freddy Guime\n - Michael Minella
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:Event sourcing - the good parts
LOCATION:402 (Tools and Techniques)
DESCRIPTION:Event sourcing can be very appealing for the auditability and
  replay capabilities it provides. However\, when used without care\, it 
 can paralyze application development\, especially after the original tea
 m members move on to other things and are replaced by new team members t
 hat were not there when history was written.  \n\nHow can we make effici
 ent use of this pattern to leverage its benefits without being slowed do
 wn by the drawbacks? In this talk we will present our experience using i
 t to develop trading engines at the Intercontinental Exchange\, and the 
 tradeoffs we made to keep it from slowing us down. \n\nSpeakers:\n - Jua
 n Bustamante
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Functional Kotlin
LOCATION:402 (Tools and Techniques)
DESCRIPTION:A brief introduction to functional programming constructs in 
 the Kotlin language. The audience will walk away with an idea of how the
 y can using functional programming ideas in their code today to make the
 ir code and their tests cleaner and easier to understand.\n\nSpeakers:\n
  - John Burns
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Writing Gradle plugins that users will love
LOCATION:402 (Tools and Techniques)
DESCRIPTION:One of the great things about Gradle Build Tool is that plugi
 ns are easy to write and there is a thriving ecosystem of freely availab
 le community plugins.  It's easy to find one or more plugins that implem
 ent desired functionality\, however\, it's hugely disappointing when a p
 lugin provides an awesome capability\, but wreaks havoc on the performan
 ce of the build\, creates undesirable side effects\, or doesn't work wit
 h a certain version of Gradle.  If only every Gradle plugin was written 
 and tested well.\n\nThis talk is intended for Gradle plugin authors who 
 want to learn how to write plugins that consumers will love to use.  We'
 ll explore the following concerns by looking at an example plugin and di
 scussing ways to improve it:\n\n- Plugin architecture\n- Task configurat
 ion avoidance\n- Configuration cache compatibility\n- Planning for and t
 esting with the build cache\n- Backwards compatibility testing \n \nYou'
 ll learn strategies for not only writing your plugin well\, but keeping 
 it healthy and well behaved as it evolves and new versions of Gradle are
  released.\n\nSpeakers:\n - Gary Hale
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Mothering A Dev Team: How Wardley Maps Saved Me!
LOCATION:402 (Tools and Techniques)
DESCRIPTION:Proper execution of a project is always easier with proper pl
 anning beforehand. Wardley Mapping is one of the best tools in our arsen
 al for seeing the road ahead clearly\, and getting to where we need to b
 e. Having learned a lot about planning while being a stay-at-home parent
 \, Valarie has a unique take on how to manage time and resources\, and e
 specially children… I mean\, coworkers.\n\nDuring this presentation we’l
 l cover the basics of Wardley Mapping\, in the context of both an automa
 tion process\, as well as a life project. Because the best tools are mul
 titaskers\, and should be able to be used for more than one purpose!\n\n
 Speakers:\n - Valarie Regas
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Mastering the Linux command line
LOCATION:402 (Tools and Techniques)
DESCRIPTION:Short version: I'll show you everything you need to know abou
 t the Linux command line as a developer.\n\n\nLong(er) version:\n\nAs a 
 developer\, you often have to deal with Linux servers. Troubleshooting\,
  digging through logs\, editing configuration files\, you name it. If yo
 u're used to working with Windows or OSX GUI's\, the Linux terminal migh
 t appear fairly basic and difficult to use.\n\nBut\, with some basic bac
 kground knowledge and a small set of terminal commands in your toolbox\,
  it can actually be extremely powerful and loads of fun!\n\nIn this sess
 ion\, I'll explain the concepts behind the Linux command line and I'll d
 emo loads of useful stuff. You'll learn how to quickly navigate\, find f
 iles\, examine and search through logs\, how to investigate a system und
 er load\, a bit of shell scripting\, ssh tunneling and more!\n\nAt the e
 nd of this session\, you'll have the chance to throw your own problems a
 nd use cases at me - I'll come up with solutions on the spot. Bring your
  own problems \;-)\n\nThis talk takes places entirely in the command lin
 e. 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!\n\nS
 peakers:\n - Bert Jan Schrijver
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T100000
DTEND:20230405T110000
SUMMARY:BDD from the Trenches
LOCATION:403 (Practices and other tech)
DESCRIPTION:Have you tried Behavior Driven Development and not gotten the
  expected results? Does the team get bogged down in arguments about whet
 her a statement is a \"given\" or a \"when\"? Are you trying to understa
 nd scenarios that run multiple pages in length? Do your specifications b
 reak when the development team refactors the UI? \n\nThis talk will pres
 ent BDD best practices learned by working with multiple teams over sever
 al years to avoid overly complex and brittle specifications\, prevent BD
 D from being yet another source of \"truth\"\, and other obstacles that 
 may prevent your teams from getting the full value out of the BDD practi
 ce\n\nSpeakers:\n - M. Jeff Wilson
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T113000
DTEND:20230405T123000
SUMMARY:Just Code isn't enough\, A successful project needs more....
LOCATION:403 (Practices and other tech)
DESCRIPTION:We’ve been working in evolving organizations with their proje
 cts and in the banking industry arise brand new digital transformation a
 reas with cloud-native journeys. At this talk\, we will share the import
 ance of a healthy culture and soft skills beyond to have great coders. W
 e modernize and improve our teams (and eventually an organization’s) to 
 increase velocity for delivering software-based projects. Let us show yo
 u how we improve and influence people\, processes\, and eventual technol
 ogy decisions.\n\nSpeakers:\n - Alberto Salazar
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T133000
DTEND:20230405T143000
SUMMARY:Developer Productivity - clean | secure | fast
LOCATION:403 (Practices and other tech)
DESCRIPTION:The old maxim of you can have it working or on time but not b
 oth is often applied to software development.\nSomehow though we’ve reac
 hed the stage where we are expected to deliver functioning code on time 
 - all the time. Isn’t that what Agile and DevOps etc are all about?   Pr
 oductivity is king after all.\nNow though we’ve got to deal with an incr
 eased focus on security - can we add that in and still deliver as before
  or does something break?\nIn this session we’ll introduce you to severa
 l ways to deal with the challenge. From better understanding of the prob
 lem to new thoughts about how we work.  We’ll help you think differently
  about productivity and show you how to take the first steps towards hav
 e your cake and eating it too\n\nSpeakers:\n - Steve Poole\n - Justin Re
 ock
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T150000
DTEND:20230405T160000
SUMMARY:Five ways open source will slow you down
LOCATION:403 (Practices and other tech)
DESCRIPTION:Software is changing the world - and even other planets. An e
 ver-growing part of software is “open source”. But it hasn’t always been
  that way! And “doing something open source” is definitely no guarantee 
 for success. There are numerous ways in which you can use open-source so
 ftware and be worse off than if you did not.\n\nJoin me in this talk to 
 find out how not to leverage open-source software in your organisation a
 nd your projects. Find out why reading the documentation may not always 
 be your best bet\, or how a workaround may eventually work against you. 
 By investigating 5 ways in which you can fail\, we can learn valuable le
 ssons on what to do instead.\n\nSpeakers:\n - Maarten Mulders
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T160000
DTEND:20230405T170000
SUMMARY:Observing Minecraft
LOCATION:403 (Practices and other tech)
DESCRIPTION:This talk will cover adding observability to your Java Minecr
 aft Server. We’ll go through exporting important metrics and logs from t
 he server to track things like player uptime and efficiency of potential
  mods. We’ll look into monitoring server health and alerting on issues i
 n real time.\nParticipants should expect to leave knowing some observabi
 lity basics and how to use the monitoring to understand system health an
 d avoid some potential incidents.\n\nSpeakers:\n - Ajuna Kyaruzi
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T073000
DTEND:20230405T090000
SUMMARY:Registration & Breakfast
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T110000
DTEND:20230405T113000
SUMMARY:Morning Break
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T123000
DTEND:20230405T133000
SUMMARY:Lunch
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T143000
DTEND:20230405T150000
SUMMARY:Afternoon Break
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230405T170000
DTEND:20230405T183000
SUMMARY:Quarkus Rocks Reception Sponsored by Red Hat and TECH NERD TRIVIA
 !
LOCATION:Foyer
DESCRIPTION:Have a great day of technical sessions. Grab a beverage and s
 nacks while listening to our resident DJ spinning on the main stage. Rel
 ax\, Recharge\, and Refresh\; mingle with fellow attendees and conferenc
 e speakers. Gather some friends to win prizes in the first ever Devnexus
  team trivia!\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T090000
DTEND:20230406T100000
SUMMARY:KEYNOTE Harnessing the Hyper-dimensional Mind: Visualizing Brain 
 Computer Interfaces
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:The future of human machine teaming will harness the human mi
 nd in ways that were the dreams of the past's science fiction. The techn
 ology is here now but researchers are challenged to understand the incre
 dible complexity of the human brain.\n\nFunctional brain computer interf
 aces are a now a nascent but rapidly accelerating field. With the physic
 al technology becoming a reality governments\, corporations and research
  facilities are racing to find ways to understand how the human mind can
  be harnessed for good.\n\nOne of the many challenges of Brain Computer 
 Interfaces is decoding and interpreting the hyper-dimensional signals th
 at come from a human brain's connected neurons. A critical method for un
 derstanding this decoding is visualization.\n\nThis keynote discussion w
 ill describe what makes a brain computer interface possible\, how it can
  be utilized and what the current limitations are. A software demonstrat
 ion will be provided which demonstrates receiving\, organizing and visua
 lizing decoded neuron data with dimensions well beyond 3D.  Animated vis
 ualizations will be provided which provide insight into the brain's acti
 ons and how such a technology could be used for good and the betterment 
 of mankind in the future. \n\nSpeakers:\n - Sean Phillips
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:My children will never deploy active-passive.
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Is your app alone and trembling in a dark\, single-region wit
 h failures\, latency\, and retry storms closing in on every side?\n\nBui
 ld a Spring Boot app with Spring Data Redis\, deploy it to a single regi
 on backed by Azure Cache for Redis Enterprise (ACRE).  Add a global load
  balancer like Azure Front Door.  Deploy the same application to multipl
 e regions\, backed my multiple instances of ACRE connected in active-act
 ive configuration.  Learn why connecting to data in a different region i
 s an anti-pattern. Demonstrate destroying an entire region to show the v
 alue of active-active level resilience. Using Terraform\, Spring Boot an
 d Azure.\n\nIn this session\, you will learn a reference architecture\, 
 for modern\, geo-distributed applications. You will learn how to moderni
 ze a single-region application\, into a multiple-region or multi-cloud a
 rchitecture. By the end of this interactive session\, your apps will be 
 able to shine bright with confidence\, resiliency\, and no more tremblin
 g.\n\nSpeakers:\n - DaShaun Carter
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:From Monolith to (µ)Services. What happens with my Data?
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Rewriting systems from a monolithic architecture to a service
 s architecture is a common task nowadays to make applications easier to 
 maintain\, deploy\, and release. This migration should not be a big bang
  rewrite where you directly switch from the old application to the new o
 ne. Instead\, it is an incremental process during which functionalities 
 are extracted one at a time into separate services.\n \nThe Strangler Fi
 g Pattern describes a method whereby a new system is slowly and incremen
 tally growing over the top of an old system. Along the way\, the whole s
 ystem is continuously monitored such that old parts can be removed after
  the new services show correct behavior. The theory is pretty clear\, an
 d in services where no persistence is needed\, it's considerably easier\
 , but things become way more complex as soon as data is involved.\n \nCo
 me to this session to learn how Kafka and Debezium\, through Change Data
  Capture and the Strangler Fig pattern\, can help you migrate from monol
 iths to a (micro)services architecture confidently even though databases
  are involved.\n\n\nSpeakers:\n - Alex Soto
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Best of Both Worlds: Apache Pulsar and Apache Kafka
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Which streaming technology is right for me? Do I need to use 
 Apache Pulsar or do I choose  Apache Kafka?\n\nThat is mostly the questi
 on\, but did you also knew that you can combine them? \n\nIn this sessio
 n we will show how to use best of both worlds. Let's compare both archit
 ectures and Java Client Implementations and decide what's best for you!\
 n\nDo you pick the battle? Or are you making allies?\nIt's up to you!\n\
 nSpeakers:\n - Mary Grygleski\n - Ko Turk
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Hands-on introduction to OpenTelemetry tracing
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:Tracking a request’s flow across different components in dist
 ributed systems is essential. With the rise of microservices\, their imp
 ortance has risen to critical levels. Some proprietary tools for trackin
 g have been used already: Jaeger and Zipkin naturally come to mind.\n\nO
 bservability is built on three pillars: logging\, metrics\, and tracing.
  OpenTelemetry is a joint effort to bring an open standard to them. Jaeg
 er and Zipkin joined the effort so that they are now OpenTelemetry compa
 tible.\n\nIn this talk\, I’ll describe the above in more detail and show
 case a (simple) use case to demo how you could benefit from OpenTelemetr
 y in your distributed architecture.\n\nSpeakers:\n - Nicolas Fränkel
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:JSON Data Modeling in Document Databases
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:If you’re thinking about using a document database\, it can b
 e intimidating to start. A flexible data model gives you a lot of choice
 s\, but which way is the right way? Is a document database even the righ
 t tool? In this session we’ll go over the basics of data modeling using 
 JSON. We’ll compare and contrast with traditional RDBMS modeling. Impact
  on application code will be discussed\, as well as some tooling that co
 uld be helpful along the way. The examples use the free\, open-source Co
 uchbase Server document database\, but the principles from this session 
 can also be applied to CosmosDb\, Mongo\, RavenDb\, etc.\n\nSpeakers:\n 
 - Matthew Groves
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T164500
DTEND:20230406T171500
SUMMARY:Mega Raffle and Conf Close
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T200000
DTEND:20230406T230500
SUMMARY:Conf After Party!
LOCATION:Sydney Marcus (Architecture)
DESCRIPTION:time to unwind with friends old and new!\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Spring Cloud Gateway: What is it and What's New.
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:To start\, we will provide a brief history of why we built Sp
 ring Cloud Gateway. Then we will provide a primer on how the gateway wor
 ks to route and filter requests. We will also provide an update on what 
 is new in the 2022.0 release train\, included: observability\, native su
 pport\, and more. To finish\, we will provide a road map update for 2023
 .\n\n\nSpeakers:\n - Spencer Gibb
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:The Future is Serverless - with Java
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Serverless cloud computing provides you with an infrastructur
 e out of the box to run your containerized Java microservices highly eff
 iciently. With MicroProfile and GraalVM\, Java integrates seamlessly wit
 h serverless infrastructure and leads to strong benefits: higher efficie
 ncy\, endless scalability\, high availability\, and the lowest possible 
 effort for the development\, production usage\, administration\, and mai
 ntenance of cloud-native Java applications.\n\nSpeakers:\n - Markus Kett
 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Next up: Spring Security 6
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:Holy deprecations\, Batman!\n\nAside from all the great nativ
 e\, observability\, and authorization features\, SAML and OAuth enhancem
 ents\, and password security improvements\, the Spring Security team did
  a lot of clean-up\, too!\n\nIn this talk\, we'll start with a secured S
 pring Security 5.8 app\, prepare it for 6.0\, update\, and then add feat
 ures like crazy. :) We may even get to use Spring Authorization Server 1
 .0 in the process.\n\nSpeakers:\n - Steve Riesenberg\n - Josh Cummings
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Reduce System Fragility with Terraform
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:As infrastructure stacks grow increasingly more complex and i
 nvolve an ever-growing number of services and systems there are a lot of
  opportunities for error and misconfiguration. To provide more system st
 ability teams have looked to abstract configuration to its own layer of 
 code. This concept of configuring infrastructure as code is gaining trac
 tion throughout the industry for a variety of reasons. It's fast\, consi
 stent\, reduces errors\, self-documentation\, and did I mention it's fas
 t? Tools such as Terraform from HashiCorp have emerged as one of the lea
 ding ways to declaratively configure technology stacks.\n\nIn this talk 
 you'll gain an understanding of the benefits of Infrastructure as Code i
 n general\, and of using Terraform specifically. You'll be introduced to
  how Terraform works\, what the code looks like\, and how to get started
 .\n\nSpeakers:\n - Scott McAllister
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:CI/CD Pipelines : What\, Why\, How?
LOCATION:302 (Cloud Infrastructure)
DESCRIPTION:To avoid getting caught up in notions of “the right tool” it 
 is important to understand the core concepts of continuous integration (
 CI) and continuous delivery or continuous deployment (CD). Choosing the 
 right tool should be a consequence of defining the right goals\, metrics
  and processes to automate. In this session we will explore common ideas
  that must be present in commercial and open source solutions to monitor
 \, automate\, verify and deliver software. \nFor example: Tasks\, Steps\
 , Runs\, End-to-end automation\, Workflows\, Tool orchestration\, Releas
 e cycles\, among others. \n\n\nSpeakers:\n - Ixchel Ruiz
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Jakarta EE 10 and Beyond
LOCATION:303 (JakartaEE)
DESCRIPTION:Java EE has been re-branded to Jakarta EE and moved to truly 
 open source governance under the Eclipse Foundation. There have so far b
 een several successful releases under the Eclipse Foundation - Jakarta E
 E 8\, 9\, 9.1 and now 10. This session overviews what this means and off
 ers a brief tour of Jakarta EE 10. We will also look at what the future 
 might bring.\n\nJakarta EE 10 brings some long pending updates to key te
 chnologies like Jakarta Security\, Concurrency\, REST\, Persistence and 
 Faces. It also brings the Core Profile targeted to next-generation runti
 mes such as Open Liberty\, Helidon and Quarkus. Down the line in Jakarta
  EE 11\, there may be further changes afoot for Jakarta Configuration\, 
 NoSQL\, Messaging\, Security\, Concurrency\, REST\, Persistence/Data\, g
 RPC and MVC. You can contribute to all this and more.\n\nYou should come
  to this session with your thinking caps on and your sleeves rolled up. 
 There is much to help move forward together that really matters.\n\nSpea
 kers:\n - Reza Rahman
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:5 years of Jakarta EE Panel: a look into the future
LOCATION:303 (JakartaEE)
DESCRIPTION:Join Jakarta EE experts as they discuss the future with versi
 on 11 and beyond. Beside Ivar Grimstad and Tanja Obradovic our panelists
  will be Emily Jiang\, Jose Paumard\, Mark Heckler\, Andrew Pielage and 
 Rudy De Busscher! \n\n\nSpeakers:\n - Tanja Obradovic\n - Ivar Grimstad
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Jakarta EE integration testing
LOCATION:303 (JakartaEE)
DESCRIPTION:Integration testing is difficult as you need additional syste
 ms\, like a database\, with a predefined set of data to have repeatable 
 tests.\n\nWith the availability of the Testcontainers framework\, develo
 pers can test the real application by deploying it in a container using 
 the runtime that will be used in production and dependencies available i
 n other containers.\n\nIn this session\, we explore a few scenarios of h
 ow you can use the Testcontainers framework to test your Jakarta EE appl
 ication\, including a remote debug session of your code.\n\nSpeakers:\n 
 - Rudy De Busscher
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:From javax to jakarta\, the path paved with pitfalls
LOCATION:303 (JakartaEE)
DESCRIPTION:The switch from javax to jakarta namespace is probably the bi
 ggest change in the Java ecosystem over the last 20 years. It does not o
 nly impact Java EE application servers\, but all libraries\, from Spring
  or Quarkus to TomEE. This presentation is about presenting the problem 
 of migrating from javax to jakarta namespace. The pitfalls and challenge
 s encountered based on a simple application example. We will go through 
 the possible options and how best companies can switch.\n\nNow that we a
 re in Jakarta\, the platform is evolving very quickly and ignoring the c
 hallenge isn’t a good bet.\n\n\nSpeakers:\n - Jean-Louis Monteiro
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Let's take a look at how a Jakarta EE cloud-native application sh
 ould look!
LOCATION:303 (JakartaEE)
DESCRIPTION:Jakarta EE 10 has arrived and along with Eclipse MicroProfile
 \, it has paved the way for Enterprise Java developers to develop easy-t
 o-maintain\, powerful applications that can be deployed on almost any en
 vironment. Jakarta EE applications can now be cloud-native applications 
 and they should no longer be constrained by how they used to look 15~20 
 years ago. DevOps engineers will greatly benefit from this talk in which
  we’ll analyse the anatomy of a Jakarta EE application that’s geared to 
 be cloud-native\, and how these applications can benefit using standards
  to their benefit and longevity.\n\nSpeakers:\n - Fabio Turizo
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Deceptive Patterns & FAST
LOCATION:304 (Web)
DESCRIPTION:Deceptive patterns (also widely known as \"dark patterns\") a
 re all over the Web. I'll speak to the accessibility impact deceptive pa
 tterns and \"dark\" patterns have as well as my introduction to taking t
 hese patterns and my work in the W3C to have these published in WCAG 3.\
 n\nThere is a lot of work being done in the Functional Needs group of th
 e W3C to introduce these to FAST. I'll talk about FAST\, what it means t
 o accessibility\, and to users\, developers\, designers\, and everyone i
 n-between in the organization.\n\nI'll also introduce people to the Fram
 ework for Accessible Specification of Technologies (FAST) which advises 
 creators of technical specifications on ensuring their technology meets 
 the needs of users with disabilities. It primarily addresses web content
  technologies but also relates to any technology that affects web conten
 t sent to users\, including client-side APIs\, transmission protocols\, 
 and interchange formats. Specifications that implement these guidelines 
 make it possible for content authors and user agents to render the conte
 nt in an accessible manner to people with a wide range of abilities.\n\n
 Speakers:\n - Todd Libby
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Typescript Deep Dive
LOCATION:304 (Web)
DESCRIPTION:Mapped types\, template literals\, conditional types with inf
 er: oh my! Come to this talk if you already understand how to use typesc
 ript day to day\, but want to take a deeper dive and understand the more
  advanced topics in Typescript through real world examples and usecases.
 \n\nSpeakers:\n - Waller Goble
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:I Can Do THAT in a Browser? Improving User Experience with Lesser
  Known Native JS APIs
LOCATION:304 (Web)
DESCRIPTION:Did you know that you can access your user's geolocation coor
 dinates via JavaScript? What about accessing a device's battery status\,
  orientation\, accelerometer\, and gyroscope? Or connecting to a Bluetoo
 th device. How about pulling data from an external device via a Serial o
 r WebUSB? Are you aware of the Fullscreen  or the GamePad API? Have an e
 -commerce app or an app that processes microtransactions? Does it use th
 e PaymentRequest API? There are tons of really cool APIs that you might 
 not be aware of. Or maybe you are aware of them\, but you're just not su
 re how to use them to improve your application? In this session\, I'll i
 ntroduce you to some of the lesser known APIs that are available in most
  modern web browsers. I'll also show you some demos that I've created wi
 th these APIs to show you how they can actually be used to make engaging
  experiences that keep your users happy and keep them coming back to you
 r site. \n\nSpeakers:\n - Todd Sharp
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Demystifying The Dreaded A/B Test
LOCATION:304 (Web)
DESCRIPTION:The A/B test! We've all thought it: \"What's the point? How m
 uch configuration do we need?\" If you're familiar with the scientific m
 ethod\, those steps carve out the path to experimentation and A/B testin
 g. Everyone loves a good hypothesis right? I know I do. Melding the worl
 d of science and software can help alleviate the stresses of experiments
  and help to maximize impact of every feature. In this talk we will jour
 ney through what an A/B test is\, defining goals for A/B testing your ap
 p\, and rolling out features based on successful experiments.\n\nSpeaker
 s:\n - Chris DeMars
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Creating a Modern Web App Using Spring Boot and Vue.js with JHips
 ter
LOCATION:304 (Web)
DESCRIPTION:In this talk\, I will demonstrate how JHipster can be used to
  generate in few minutes a modern Web app that uses Spring Boot and Vue.
 js. JHipster will provide everything you need to start a complete modern
  Web app and take it to production in a very short amount of time. On to
 p of that\, the back-end is built as a high-performance and robust Java 
 stack with Spring Boot. More details can be found here: https://www.jhip
 ster.tech/.\n\nSpeakers:\n - Théo Lebrun
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Loom Virtual Threads in the JDK 20
LOCATION:305 (Core Java)
DESCRIPTION:The Loom project has been under work for many years\, and jus
 t delivered Virtual Threads as a preview feature in the JDK 19 and JDK 2
 0. We now have a very precise idea of what they are and what you can do 
 with them. Our good old Threads\, created more than 25 years ago\, will 
 see a new kind of lightweight threads. This presentation shows you that 
 creating a thread is easier and much cheaper\, allowing the creation of 
 millions of them in a single JVM. These virtual threads can be block at 
 almost no cost. These new virtual threads bring with them new notions th
 at will be covered in this talk. Loom threads are coming\, and they will
  change the landscape of concurrent programming in Java.\n\nSpeakers:\n 
 - José Paumard
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:To Java 20 and Beyond!
LOCATION:305 (Core Java)
DESCRIPTION:Java 17 has come and gone\, but development on Java continues
  on! What has changed since Java 11? And what changes are being added in
  Java 20? Come find out!\n\nIn this presentation we will look at the key
  changes that have been added to Java post-8\, focusing primarily on Jav
 a post-11. The large changes\; the Module System and Records\, quality o
 f life improvements\; var\, text blocks\, pattern matching\, and the man
 y performance and runtime improvements. A lot has changed in the JDK in 
 recent releases\, take this opportunity to get caught up! \n\nSpeakers:\
 n - Billy Korando
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Panel Session: Moving the Java Community Forward
LOCATION:305 (Core Java)
DESCRIPTION:Over the last 25+ years\, Java has offered developers a wealt
 h of technical value. The technical heartbeat is strong and vibrant. But
  as we look towards the next 25 years and beyond\, the value of Java is 
 dependent on...YOU. It's the community who gives life to Java\, ensuring
  it meets the needs of modern application development. For Java\, the fu
 ture isn't some distant dot on a calendar\, the future is NOW. In this p
 anel session\, learn from some of the most recognized Java community lum
 inaries how you can participate to ensure Java moves forward.\n\nSpeaker
 s:\n - Sharat Chander
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Data Focused programming with Pattern Matching in Java
LOCATION:305 (Core Java)
DESCRIPTION:Data is at the heart of most applications. For ages\, Java de
 velopers have been using conditions to determine whether an instance is 
 of a specific type - to extract its components. Though this sounds obvio
 us and harmless\, Pattern Matching has revolutionized how you achieve th
 is in your everyday code in a concise and focused way.\n\nWorking with i
 ts syntax seems simple and straightforward. Pattern Matching can be used
  with operators like instanceof\, and constructs like switch statements 
 and expressions. But\, don't let this simplicity deceive you. Its real p
 ower lies in understanding the semantics of working with Patterns like T
 ype Patterns\, Parenthesized Patterns\, Record Patterns and others to wr
 ite declarative and data-focused code to create powerful\, declarative a
 nd composable data navigation and processing. \n\nIn this live-coded tal
 k\, the attendees will learn about the issues with their existing code\,
  create concise and clear data-focused queries\, and modify existing cod
 e bases to avail benefits of Pattern Matching.\n\nSpeakers:\n - Mala Gup
 ta
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Revisiting Design Patterns after 20
LOCATION:305 (Core Java)
DESCRIPTION:In 1994\, the Gang of Four brought to us 23 different design 
 patterns that helped thousands\, maybe millions of developers\, to desig
 n better code and share a common language. Almost three decades later\, 
 improvements in the Java language allow us to revisit most of these desi
 gn patterns and propose novel ways to solve the same problems.\n\nJoin u
 s at this talk when we perform some live refactorings of code using lega
 cy implementations of design patterns into new code using the latest imp
 rovements of Java 20. Come and witness how Strategy\, Template Method\, 
 Visitor\, Command\, Decorator\, Builder\, and other patterns can signifi
 cantly benefit from modern features of Java\, such as lambdas\, records\
 , switch expressions\, and much more.\n\nSpeakers:\n - Edson Yanaga
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T074500
DTEND:20230406T084500
SUMMARY:Women in Technology Breakfast
LOCATION:311 (Security)
DESCRIPTION:Building a career in tech: the good\, the bad and the ugly\n\
 nJoin us for breakfast with some of the amazing women in tech. Our panel
 ists will discuss some of the advice they received throughout their care
 ers in tech and if there is anything they wish they had done differently
 . \n\nSpeakers:\n - Najae Stevenson\n - Cecelia Martinez\n - Emily Jiang
 \n - Valarie Regas\n - Gail Anderson
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Don't Trust anyone.... Secure your Microservices with ZeroTrust a
 pproach.
LOCATION:311 (Security)
DESCRIPTION:Edge trusting is dead\, long live Zero Trust.\n\nWe were used
  to deal with `edge security` \, direct integration with IDPs using diff
 erent libraries\, also dealing with certificates\, SSL\, securing the po
 int of entrance to our system\, and after that.... well\, if you are in 
 the system is because you are allowed to ...... or not ?\n\nNowadays CVE
 s\, massive attacks\, are common .... for sure you remember some recent 
 cases ....don't you ?\n\nSo\, the idea of protecting only the most exter
 nal layer of our system \, based on the idea that nobody can be in the s
 ystem if that gate has not been successfully passed\, is no longer valid
 .\n\nIn this session I will share my knowledge on protecting K8s and VMs
  clusters following the ZeroTrust approach\, covering concepts like : Ze
 ro Trust security\, SSL transport\, Observability\, Authz and Authn \, a
 nd everything without touching a single line of our Java ( Quarkus ) mic
 roservices and how to change that configuration without telling a word t
 o the app developer.\n\nSpeakers:\n - Jonathan Vila
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:A Community Approach to OSS Distribution
LOCATION:311 (Security)
DESCRIPTION:There are a variety of different attacks on the open source s
 upply chain\, including exploitation of zero day vulnerabilities\, injec
 tion of malicious code or back-doors\, and typo-squatting of popular lib
 raries. And the systems that we rely upon for the distribution of OSS we
 re not designed with a security mindset to prevent these sorts of attack
 s. There has to be a better way for open source authors and maintainers 
 to securely deliver their packages to end users!\n\nEnter Pyrsia\, a new
  software distribution system that is decentralized\, community-driven\,
  foundation governed\, and built with a security first focus. In this pr
 esentation we will talk about how Pyrsia is designed\, how you can use i
 t to distribute and consume software packages\, and how you can get invo
 lved in the Pyrsia community to grow the library of OSS software availab
 le freely and securely for all.\n\nSpeakers:\n - Stephen Chin
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Keeping It SAST-y
LOCATION:311 (Security)
DESCRIPTION:SAST\, SCA\, DAST\, IAST\, RASP? What is the meaning of all t
 hese security tools and what do they mean to developers? With the threat
  to application security ever increasing\, it is more important than eve
 r to understand how to leverage tooling effectively to be your trusty si
 dekick in the battle against cybercrime.\n\nIn this session\, we’ll dive
  into static application security testing (SAST)\, static analysis conce
 pts\, and the strategies behind it. We’ll also discuss how to take advan
 tage of tools to painlessly improve code security.\n\nSpeakers:\n - Ther
 esa Mammarella\n - Eddie Knight
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Best Practices for Securing Cloud Native Applications
LOCATION:311 (Security)
DESCRIPTION:Microservices are the foundation for building your applicatio
 n in the cloud and\, just like with legacy applications\, security is of
  the upmost importance.  How do you properly secure a Microservice creat
 ed for the Jakarta Enterprise Edition or MicroProfile specifications?  W
 hat are some best practices for authenticating users and authorizing the
 m to access your MicroService?  Join me for an overview of Microservice 
 security\, with samples based on the Open Liberty application server.\n\
 nSpeakers:\n - Mark Stoodley
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Minimum Viable Security for Cloud Native Stacks
LOCATION:311 (Security)
DESCRIPTION:The migration from monoliths to microservices is long behind 
 us\, however managing microservices operations at scale comes with a lay
 er of complexity\, particularly with aspects of security that still have
  a learning curve.  But what if all of this could be simplified and auto
 mated pretty easily?\n\nIf we think about our production microservices o
 perations\, in the same way we think about how we design and build our p
 roducts\, we could build and automate minimum viable security plans that
  we could easily bake into our config files and CI/CD processes.  Once w
 e build this foundational framework of security\, it will always be poss
 ible to iterate and evolve our security framework\, for advanced layers 
 of security that often comes with time\, increased experience\, and grea
 ter maturity around security.\n\nIn this talk\, we will present what MVS
  looks like for microservices operations\, how to build a cluster secure
 d by design\, continuously monitoring networking\,  container internals 
 and primitives\, and access management with a least privilege principle 
 mindset. In this session we will demonstrate this through code\, and eve
 n how this can work seamlessly with other ecosystem projects - from Helm
  to OPA\, ArgoCD\, Notary or Github Actions\, Terraform\, and AWS.\n\nSp
 eakers:\n - Chris Koehnecke
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Java to Kubernetes for dummies
LOCATION:312 (Unobtanium)
DESCRIPTION:Kubernetes\, it looks really great. Think about the great fea
 tures: scaling\, reproducibility\, etc. Everyone is talking about it\, i
 t's hype! So\, Let's migrate our Java apps to the cloud and Kubernetes!\
 n\nWait a minute ... Have you seen all these YAML files? We hate YAML! I
 t is already a full time job to maintain our Java applications but now w
 ith Kubernetes\, we also have to\n\n- write and maintain Dockerfile file
 s\n- write and maintain YAML files\n- configure and rething our existing
  CI/CD and deployment architecture\n- etc.\n\nYes during this talk\, we 
 are going to suffer 👿 ... but I promise\, I will guide you\, teaching y
 ou the basics of Kubenetes to move your Java apps. I will also show you 
 a way to move your Java apps to Kubernetes with only 6 lines of XML 🤣\n
 \nSpeakers:\n - Sun Tan
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Change Data Streaming Patterns in Distributed Systems
LOCATION:312 (Unobtanium)
DESCRIPTION:Microservices are one of the big trends in software engineeri
 ng of the last few years\; organizing business functionality in several 
 self-contained\, loosely coupled services that help teams work efficient
 ly\, and make the most suitable technical decisions.\n\nIn this session\
 , we will discuss and showcase how open-source change data capture (CDC)
  using Debezium can help with the challenges developers often face when 
 working with microservices.  The session will not only cover what is CDC
  and how Debezium works\, but it will include three critical patterns\, 
 Outbox\, Stranger Fig\, and Saga. We will discuss these patterns in-dept
 h and discover how they overcome the challenges when working with micros
 ervices.\n\nSpeakers:\n - Chris Cranford
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:A Call to (GitHub) Actions!
LOCATION:312 (Unobtanium)
DESCRIPTION:Since the dawn of ... the epoch?\, engineers have been trying
  to automate away the boring\, repetitive stuff.  These days thanks to t
 he rise of Continuous Integration and Continuous Deployment practices\, 
 we've never had a richer set of tools.  On the flip side\, it can hard t
 o know how to wire it all up to meet your specific needs.  In this talk 
 we'll cover some of these options using GitHub Actions and see how we ca
 n automate\, and better yet reuse that automation\, to make your project
  management one less reason to lay awake at night.  Join me as I share t
 he lessons learned and practices developed in both my professional and p
 ersonal software projects.\n\nSpeakers:\n - Justin Lee
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Event-driven autoscaling for Serverless Java
LOCATION:312 (Unobtanium)
DESCRIPTION:Kubernetes makes it possible to autoscale various business us
 e cases from web apps to mobile\, IoT edge streaming\, and AI/ML in more
  reliable and stable ways. One caveat of the Kubernetes autoscaling is b
 ased on hardware resource utilization (CPU\, memory) through Horizontal 
 Pod Autoscaling. This causes a new challenge to build an event-driven se
 rverless Java on Kubernetes because the event metrics from multiple even
 t sources (e.g.\, Apache Kafka\, AWS SQS) are more relevant than a pod's
  CPU usage for deciding when applications need to be scaled out and in. 
 \n\nFortunately\, KEDA and Knative on Kubernetes are designed to solve t
 his challenge by autoscaling both standard apps and serverless by event 
 metrics in a separate way. This session will teach you how to redesign y
 our Kubernetes autoscaling architecture by event-driven metrics from Apa
 che Kafka over standard resources (CPU\, Memory) with Knative and KEDA i
 ntegration for serverless Java using Quarkus.\n\n\nSpeakers:\n - Daniel 
 Oh
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Why You Should Be Doing Contract First API Development
LOCATION:312 (Unobtanium)
DESCRIPTION:How do you develop APIs and services efficiently and effectiv
 ely while improving software quality and team productivity? That's calle
 d contract-first API development! By using tools like OpenAPI specificat
 ion and generator tooling capable of leveraging it\, you can leap ahead 
 in your development by generating lots of the boilerplate code\, some of
  your tests\, and allowing multiple parallel workstreams within your tea
 m. In this session I will show you examples of how you can fast track yo
 ur API and service development today!\n\nSpeakers:\n - Daniel Vaseekaran
 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Introduction to Rancher Desktop
LOCATION:313 (Cloud Tech)
DESCRIPTION:Let's explore Rancher Desktop\, a full Kubernetes development
  environment for your Desktop that is 100% free and completely Open Sour
 ce.  If your development team is concerned about “new” licensing require
 ments of a popular Kubernetes Desktop software that is NOT Open Source\,
  then you need to take a closer look at Rancher Desktop\, a FOSS project
  backed by SUSE. Rancher Desktop runs on Linux\, Windows\, and Mac. Deve
 lopers can easily change container runtimes and Kubernetes versions to m
 atch deployment targets.    https://rancherdesktop.io/\n\nSpeakers:\n - 
 Dwain Sims
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Knative Core Concepts! And Spiders!
LOCATION:313 (Cloud Tech)
DESCRIPTION:Although Knative has been community-maintained since 2018\, t
 here has been buzz around the project lately because Knative has recentl
 y been accepted to the Cloud Native Computing Foundation (CNCF) as an in
 cubating project.\n\nCool! But what is Knative\, exactly?\n\nSimply put\
 , Knative is a technology that streamlines and enhances the way that app
 lications run on Kubernetes.\n\nThis talk is for people who are excited 
 about this value proposition and want to dig deeper. How does it work? W
 hat components are at play? In what ways is running an app on Knative su
 perior to running it directly on Kubernetes?\n\nInstead of presenting sl
 ides\, Whitney will diagram the fundamental concepts of Knative\, explai
 ning how they work in simple\, relatable terms. She will then drive deep
 er understanding with a live coding demo that gives context to the main 
 points. With spiders and rainbows. You know\, a real-life\, straightforw
 ard\, run-of-the-mill use case.\n\nAttend this talk to gain a high-level
  understanding of Knative\, its main components\, and how it simplifies 
 and improves the way that apps run on Kubernetes.\n\nSpeakers:\n - Whitn
 ey Lee
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Make your container apps smarter with sidecars and actions
LOCATION:313 (Cloud Tech)
DESCRIPTION:Distributed Application Runtime (Dapr) provides open-source A
 PIs that make your Kubernetes applications better and smarter\, and help
  you write resilient and secure polyglot microservices. This session is 
 almost completely demos.  I’ll show how to safely manage code updates to
  a polyglot application\, and automated CI/CD deployment to multiple app
 lication targets with a single update via GitHub actions.  \n\nSpeakers:
 \n - Brian Benz
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Testing cloud-native applications with ease!
LOCATION:313 (Cloud Tech)
DESCRIPTION:Many applications rely on cloud solutions like AWS\, Azure\, 
 and GCP. Testing such applications could be a nightmare of spare cloud a
 ccounts or never-ending environment setups. \n\nThanks to Testcontainers
 \, we can run all the necessary services locally and even more programma
 tically control their configuration and lifecycle! It means you can impr
 ove your development feedback loop locally and test your cloud-native ap
 plications without spending a penny. \n\nIn this demo-heavy session\, we
 ’ll go over typical use cases cloud-native app developers struggle to te
 st effectively\, and look at how Testcontainers features enable working 
 with S3\, DynamoDB\, Lambdas\, Google Spanner\, and others. Testing your
  cloud-native applications with Localstack and GCloud modules has never 
 been this easy and reliable. \n\nSpeakers:\n - Oleg Šelajev
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Kontain Your Spring
LOCATION:313 (Cloud Tech)
DESCRIPTION:Although Java originally promised write once\, run anywhere\,
  it failed to fully deliver on that promise. As developers\, we can deve
 lop\, test\, and build our applications into WAR or executable JAR files
  and then toss them over the wall to a Java application server and Java 
 runtime that we have no control over\, giving us zero confidence that th
 e application will behave the same as when we tested it.\n\nContainers f
 ulfill the write-once\, run anywhere promise that Java wasn't able to\, 
 by packaging the runtime and even the operating system along with our ap
 plication\, giving greater control and confidence that the application w
 ill function the same anywhere it is run. Additionally\, containers affo
 rd several other benefits\, including easy scaling\, efficiency in terms
  of resource utilization\, and security by isolating containers from the
 ir host system and from other containers.\n\nWhile deploying Spring appl
 ications in containers has always been possible\, Spring Boot makes it e
 asier to containerize our applications and run them in container archite
 ctures such as Kubernetes. Spring Boot's support for containerization in
 cludes two options: Creating containers based on buildpacks or using lay
 ers as a means of modularizing and reducing the size of our application 
 deployments. Moreover\, new components in the Spring ecosystem can make 
 your Spring applications Kubernetes-savvy so that they can take advantag
 e of what a containerized architecture has to offer.\n\nIn this example-
 driven session\, we're going to look at how to create and deploy Spring 
 applications as container images and deploy them into a Kubernetes clust
 er. Along the way\, we'll also get to know a few of the most useful tool
 s that a Spring developer can employ in their development workflow when 
 building containerized Spring applications. We'll also see how to apply 
 patterns of Spring Cloud--such as configuration\, service discovery\, an
 d gateways--using native Kubernetes facilities instead of Spring Cloud c
 omponents. And we'll look at how components of the Spring ecosystem can 
 work with your Spring applications to enable them to thrive in a Kuberne
 tes cluster.\n\n\nSpeakers:\n - Craig Walls
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Apache Pulsar Development 101 with Java
LOCATION:314 (Frameworks)
DESCRIPTION:In this session I will get you started with real-time cloud n
 ative streaming programming with Java.  \n\nWe will start off with a gen
 tle introduction to Apache Pulsar and setting up your first easy standal
 one cluster.   We will then l show you how to produce and consume messag
 e to Pulsar using several different Java libraries including native Java
  client\, websockets\, MQTT and even Kafka.   \n\nAfter this session you
  will building real-time streaming and messaging applications with Java.
   We will also touch on Apache Spark and Apache Flink.\n\nSpeakers:\n - 
 Timothy Spann
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Introducing Spring for Apache Pulsar
LOCATION:314 (Frameworks)
DESCRIPTION:Spring for Apache Pulsar is a library that makes it easy to c
 reate stand-alone\, production-grade Spring based Applications using Apa
 che Pulsar that you can \"just run\". \n\nIn this talk we will explore S
 pring for Apache Pulsar by looking at the core features that it provides
 . We will see how this library unlocks developer velocity via Spring Boo
 t foundations when designing pub-sub solutions with Apache Pulsar . \n\n
 You will witness a live demo where we create a basic Spring for Apache P
 ulsar app and evolve it from imperative -> reactive -> native. \n\nApach
 e Pulsar is a cloud-native\, multi-tenant\, high-performance solution fo
 r server-to-server messaging and queuing built on the pub-sub pattern. P
 ulsar combines the best features of a traditional messaging system like 
 RabbitMQ with those of a pub-sub system like Apache Kafka.\n\nSpeakers:\
 n - Chris Bono\n - Christophe Bornet
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Beyond REST and CRUD: Integration patterns in Microservices
LOCATION:314 (Frameworks)
DESCRIPTION:The flow of information and events through distributed system
 s goes well beyond HTTP\, REST\, and JSON. In this talk\, we’ll use Apac
 he Camel to explore integration patterns that add flexibility and resili
 ence to your evolving architecture.\n\nSpeakers:\n - Erin Schnabel
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Spring Cloud Stream Past\, Present\, and Future.
LOCATION:314 (Frameworks)
DESCRIPTION:Spring Cloud Stream is a framework for building highly scalab
 le microservices connected to shared messaging systems. Together with Sp
 ring Cloud Function\, Spring Cloud Task and other frameworks from the Sp
 ring Cloud portfolio\, it is evolving and quickly becoming a go-to solut
 ion for users who want to spend more time concentrating on functional as
 pects of their microservices while guarding themselves from nonfunctiona
 l (boilerplate) concerns such as connectivity\, integration\, and many o
 thers. In this \"state of the union\" session (50/50 presentation/live-c
 ode)\, Glenn will discuss and demonstrate the current features\, the rec
 ent changes and enhancements\, and talk about what's coming in the futur
 e.\n\nSpeakers:\n - Oleg Zhurakousky
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:To Production and Beyond: Observability for Modern Spring Applica
 tions
LOCATION:314 (Frameworks)
DESCRIPTION:You just deployed your application to prod. Congratulations! 
 Is our mission accomplished and can we go home for the week even if it i
 s just Tuesday? But before we pack up to go home\, how will we know if w
 e deployed a bug or if our last change caused a significant performance 
 degradation? Also how can we know when network issues arise or if one of
  our dependencies goes down?\nIn this forward-looking presentation\, we 
 will answer these questions by looking into application observability us
 ing distributed tracing\, metrics\, correlated logs\, and exemplars. We 
 will explore how the latest developments in Micrometer\, Spring Framewor
 k 6\, Spring Boot 3\, Prometheus\, OpenZipkin\, and OpenTelemetry will g
 ive you a better understanding about what is going on inside of your app
 lications. \nWe will also discuss the future of Observability in Spring 
 Boot and other methods of exploring your running application using Sprin
 g Boot Actuator\, Spring Boot Admin and Spring HATEOAS along with relate
 d technologies like Eureka\, Logbook and Swagger.\n\nSpeakers:\n - Jonat
 an Ivanov
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Journey to cloud : leave no Java workload behind
LOCATION:315 (Java Platform)
DESCRIPTION:The shift towards cloud and container technologies is driving
  a number of innovations in the Java ecosystem. With the growing importa
 nce of startup time and memory footprint\, features developed in the Ecl
 ipse OpenJ9 JVM like remote JIT servers and using CRIU to snapshot/resto
 re Java applications are increasingly relevant for modern Java deploymen
 ts. You may have read about or watched a talk about these exciting new t
 echnologies\, but in this talk we're going to pull together the full lan
 dscape for you. We'll explain how snapshot/restore and JIT servers and a
 ll the other performance and footprint enhancements developed at OpenJ9 
 fit together as a compelling and cooperative solution to optimize Java f
 or the cloud. Come to this talk to learn more about our vision and strat
 egy for the future of Java performance\, where no Java workload is left 
 behind in the journey to the cloud.\n\nSpeakers:\n - Vijay Sundaresan\n 
 - Mark Stoodley
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Leading Edge! Changing the Java World with Loom\, Panama\, and Mo
 re
LOCATION:315 (Java Platform)
DESCRIPTION:So many new toys! Over the past several years\, JVM engineers
  have quietly started to land the largest and most important features in
  the history of Java. Project Loom brings \"virtual threads\"\, lightwei
 ght userland concurrency and massive horizontal scaling. Project Panama 
 brings native function and memory support\, blurring the lines between J
 ava and native languages like C. And there's even more coming soon. We'l
 l explore how JVM languages like JRuby can leverage these and other feat
 ures\, and talk about what the future holds.\n\nSpeakers:\n - Charles Nu
 tter
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Say the Words:  Modern Java with JavaFX for Rich Client UIs
LOCATION:315 (Java Platform)
DESCRIPTION:Wordle is a popular online game where you have up to six trie
 s to guess a hidden five-letter word. By combining the power of the Java
 FX UI toolkit with the latest Java Development Kit features\, we show ho
 w to implement a version of Wordle for desktop and mobile devices (iOS a
 nd Android). \n\nLearn how to create the main UI layout with Scene Build
 er and use specialized UI controls with pseudo-classes for CSS styling. 
 Understand JavaFX property binding to control UI state and use JavaFX an
 imation for cool looking effects. We'll also use modern Java including l
 ambdas\, streams\, method references\, records\, and enhanced switch exp
 ressions.\n\nSpeakers:\n - Paul Anderson\n - Gail Anderson
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:From Java 17 to 21 and beyond: Loom\, Amber and Valhalla
LOCATION:315 (Java Platform)
DESCRIPTION:The two years realese cadence of LTS versions gives the entir
 e Java ecosystem the opportunity to accelerate. It also brings the new f
 eatures Java has to offer faster\, so that developers can improve applic
 ations readability\, maintainability as well as development productivity
 . \nThis presentation covers three of the new features of the JDK: Amber
 \, Loom and Valhalla. Amber is about bringing pattern matching to the Ja
 va language. It's currently added bit by bit: records\, pattern matching
  for instanceof\, for switch\, and record pattern matching. Loom offers 
 a new concurrent programming model. With Loom\, you can write your code 
 in a synchronous way\, without any callback\, and execute it asynchronou
 sly\, with all the performances benefits you may expect. It is a preview
  feature of the JDK 19. Valhalla brings a new kind of objects to the lan
 guage\, so that you do not have to choose between performances and abstr
 action. Valhalla will add user defined primitive types to the Java langu
 age as well value types.\n\nSpeakers:\n - José Paumard
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Should I upgrade my Java?
LOCATION:315 (Java Platform)
DESCRIPTION:Java 11 was released in September 2018\, and Java 17 was rele
 ased in 2021. However\, even today\, plenty of developers still use Java
  11 or even Java 8. The motivation behind this talk is to make a compell
 ing argument for an upgrade from Java 8 or 11 to Java 17. In this sessio
 n\, Nikhil will showcase the new features\, demonstrate improvements\, p
 rovide performance comparisons\, and briefly discuss upgrade strategies.
  At the end\, you’ll be able to answer the question\, “Should I upgrade 
 my Java?”\n\nSpeakers:\n - Nikhil Nanivadekar
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Wired! How your brain learns new (programming) languages
LOCATION:402 (Tools and Techniques)
DESCRIPTION:How much do you know about the computer that you are? The com
 puter we call “our brain”? And do you sometimes struggle with learning t
 he new programming languages or the features of a new Java version (let’
 s say Java 17)? Yes?! In that case\, this talk is something for you!\n\n
 In this talk we’ll look at learning a new language from a Linguistic and
  Neurological perspective\, while at the same time looking at how we can
  apply this in the IT setting we work in. At the end of this talk you wi
 ll know how your brain stores new information and how that information c
 an be retrieved and used. Next to that you will be given some practical 
 tips and tricks on how to improve your own learning curve and how to hel
 p others support others who are in the process of learning.\n\nAs a prev
 ious speech-and-language therapist I would like to give you a better und
 erstanding of how we learn languages and how this knowledge can help us 
 in the never-ending changing world of software development!\n\nSpeakers:
 \n - Simone de Gijt
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Unlocking Value from Time Series Data with Open Source Tools in J
 ava
LOCATION:402 (Tools and Techniques)
DESCRIPTION:Join Zoe\, Developer Advocate at InfluxData\, for a session w
 here she will share how to take charge of your time series data with Inf
 luxDB open source time series platform using Java. In this session\, you
 ’ll learn how open source tools like Telegraf and InfluxDB can help you 
 build real-time applications faster and with less effort. We will also d
 emo how to use InfluxDB to gain visibility and insight into your time-st
 amped data from the edge to the cloud.\n\nSpeakers:\n - zoe Steinkamp
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:What's Cooking in Maven?
LOCATION:402 (Tools and Techniques)
DESCRIPTION:It’s been over 10 years since Maven 3 saw the light\, bringin
 g initial multi-module support. Later releases brought a lot of improvem
 ents\, bug fixes\, and of course coloured output.\n\nBut the Maven commu
 nity hasn’t been resting on their laurels. A lot of effort has gone into
  the future of Maven. You may have heard about Maven 4\, Maven Wrapper\,
  or Maven Daemon. Why should you care? And how will it change the way yo
 u use Maven? I will show you by using the latest snapshot builds of Mave
 n - time will tell if that’s a brave or a stupid idea…\n\nJoin me to fin
 d out what the future of Maven has for you!\n\nSpeakers:\n - Maarten Mul
 ders
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:The Programmer's Guide to JDK Flight Recorder
LOCATION:402 (Tools and Techniques)
DESCRIPTION:The JDK Flight Recorder (JFR) is an event-based diagnostic an
 d profiling tool built into the JDK. JFR can provide detailed informatio
 n about the performance of a JVM and Java applications running on it and
  help diagnose when something goes wrong in production. JFR has several 
 powerful and flexible APIs for capturing\, streaming\, and filtering inf
 ormation. This presentation will focus on how programmers can take advan
 tage of these APIs for testing\, capturing valuable data\, providing liv
 e metrics\, and more! If you have been wondering how to improve the perf
 ormance of your Java applications or get better insight into their inter
 nal workings\, this presentation is for you!\n\nSpeakers:\n - Billy Kora
 ndo
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:Going Beyond Test-Driven Development
LOCATION:402 (Tools and Techniques)
DESCRIPTION:Test-Driven Development (TDD) is a simple three-step practice
 \, and its practitioners regularly deliver higher-quality code in less t
 ime. So why aren't we all doing it? Unfortunately\, most programmers fin
 d it difficult to adopt the TDD process as it is usually taught. But\, w
 hat if there was an easier way?\nIn this session\, you will learn how to
  avoid the limitations caused by the way TDD is usually taught\, and how
  to avoid the most common problems developers have with writing automate
 d tests. You will also learn how to leverage the process to minimize the
  time you spend debugging -- which leaves you with more time for the fun
  parts.\n\nSpeakers:\n - Burk Hufnagel
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T100000
DTEND:20230406T110000
SUMMARY:Shifting Left with Kubernetes
LOCATION:403 (Practices and other tech)
DESCRIPTION:The Shift Left philosophy is a product of the Agile movement.
  Its practices encourage teams to test and validate software as early in
  the process as possible. It’s been shown that the earlier issues are fo
 und and addressed that overall quality\, time to delivery\, and project 
 costs improve. As teams adopt Shift Left\, one notable exception is ofte
 n overlooked. That is deployment. Over the past decade\, application dep
 loyment has steadily become more of a software effort. The argument can 
 easily be made that validating application deployment\, which has primar
 ily become a software effort\, is just as much a candidate for Shift Lef
 t as the application itself. With containerization continuing its rise o
 n becoming the application deployment norm\, the notion of a production-
 like system deployed as far left in the cycle as a developer’s workstati
 on is a practical reality. In organizations that have adopted Kubernetes
 \, each phase of the delivery pipeline is able to accurately replicate a
  production environment.\n\nIn this session\, we will examine the benefi
 ts and challenges of Shifting Left by building and validating Kubernetes
 -based deployments. Topics include replicating production environments s
 tarting with development workstations\, strategies for maintaining deplo
 yment code alongside application source code\, considerations for artifa
 ct registries and repositories\, and tooling that can assist at each sta
 ge.\n\n\nSpeakers:\n - Ray Elenteny
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T113000
DTEND:20230406T123000
SUMMARY:Things we've learned about better software delivery principles th
 rough a pandemic
LOCATION:403 (Practices and other tech)
DESCRIPTION:Since early 2020\, software delivery has undergone quite a sh
 ift in process and practices and how we understand \"high-performing eng
 ineering teams.\" At the same time\, the demands placed on our developme
 nt and operations teams have continued to increase.\nWith anonymous data
  collected from over 1M+ devs\, 45K+ orgs\, and 250M+ workflows\, we've 
 found some interesting insights into better DevOps practices. In this se
 ssion\, we will seek to uncover what this unique dataset can tell us abo
 ut high-performing teams\, and steps to get there as a business.\n\nSpea
 kers:\n - Jeremy Meiss
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T133000
DTEND:20230406T143000
SUMMARY:Unlocked : Growing Your Skills Through Open Source Development An
 d Civic Hacking
LOCATION:403 (Practices and other tech)
DESCRIPTION:As a developer\, we want to increase our knowledge of the dev
 elopment world around us so that we can help grow our careers or help th
 e world.   Many folks can grow their career through reading blogs\, book
 s\, following tutorials or watching videos. But some of us need a projec
 t or community to help us attain our career growth. Where can we find th
 ese projects or the community? In this discussion\, we will show you 2 p
 aths that you can take advantage of\, so that you can give to the commun
 ity and grow your career. \nThe first path that we will discuss is how t
 o contribute to an open-source project. This includes the who\, what\, a
 nd how of open source and the places where you can contribute to an open
  source.   Spoilers: Anyone can contribute\, and you need not be a coder
  to contribute. \nThe second path we'll discuss is Civic Hacking. We wil
 l define what it is\, where to get involved and cover its basic tenets:\
 n- Do what you can?\n- Where you can?\n- With what you've got?\n\n\nSpea
 kers:\n - Nerando Johnson\n - Glenn Renfro
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T144500
DTEND:20230406T154500
SUMMARY:Calculating the Value of Pie: Real-Time Survey Analysis With Apac
 he Kafka®
LOCATION:403 (Practices and other tech)
DESCRIPTION:These days\, it’s difficult to keep up with friends and famil
 y\, even more so when important things are involved––like pie. Do you fi
 nd yourself wishing that you could quickly and efficiently poll your lov
 ed ones\, peers\, and colleagues for their pastry preferences? Look no f
 urther. This talk explores how to create an interactive\, real-time surv
 ey bot with Telegram and Apache Kafka® and how to analyze the survey res
 ponses using ksqlDB.\n\nKafka Producers and Consumers are the main ingre
 dients that come together to make an interactive Telegram bot that issue
 s on-demand surveys to friends and family. Survey responses are written 
 to Kafka in real-time where ksqlDB helps to measure\, mix\, and knead th
 e data––serving up a fresh and delicious result that we can consume imme
 diately! In this session\, you’ll see the entire pipeline from start to 
 finish\, learning how to think about data and use schemas\, how to confi
 gure Producers and Consumers\, and how to use ksqlDB for both stateless 
 and stateful processing. \n\nCome along to see how this recipe for real-
 time survey analysis comes together––and how you\, too\, can calculate t
 he value of pie!\n\nSpeakers:\n - Danica Fine
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T154500
DTEND:20230406T164500
SUMMARY:CAPES aren't just for super heroes... They're for you too!
LOCATION:403 (Practices and other tech)
DESCRIPTION:CAPES is an acronym for the top soft skills needed in technol
 ogy today\; Communication/Collaboration\, Adaptability\, perseverance\, 
 Empathy and self-awareness. Because hard skills generally create revenue
 \, we hire individuals based on their technical skills but we fail for i
 dentify how the lack of soft skill can negatively impact the company's l
 edger. \nThis 50 minute session will define the 5 soft skills most promi
 nent in technology today\, detail the pros and cons of soft skills in th
 e workplace\, list ways that soft skills can help you in your career and
  identify ways we can improve these skills in our everyday lives. \n\nSp
 eakers:\n - Najae Stevenson
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T080000
DTEND:20230406T090000
SUMMARY:Breakfast
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T110000
DTEND:20230406T113000
SUMMARY:Morning Break
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T123000
DTEND:20230406T131500
SUMMARY:Lunch
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20230404T191554Z
DTSTART:20230406T143000
DTEND:20230406T145000
SUMMARY:Afternoon Break
LOCATION:Foyer
DESCRIPTION:null\n\nSpeakers:\n - 
END:VEVENT
END:VCALENDAR