Registration & breakfast

Breakfast

Break

The best time to take coffee or juice

Coffee Break

The best time to talk with speakers and attendees

Lunch Break

Keynote

Opening ceremony (Room 9)

Closing ceremony (Room 9)

TBA

To Be Announced

Lightning talk

Topic tables

Join other attendees and share ideas, talk about the recent challenges, or find solution for a problem. During this session you can connect with other like-minded people in a space designated for certain languages, technologies, and interests.
1. Suggest a topic
Look for large white sheets of paper, and tell everyone what is on your mind! You can also tweet using #topicforgeecon hashtag. Vote for topics (mark it with line/x/heart) and like tweets to show others you’re interested.
2. Choose a room and have fun
We will group similar topics and assign a room. Topics will be pinned before room entrance (list of topics and rooms will be also posted using attendees slack channel - slack.geecon.cz), so you will be able to join others also interested in eg. Kotlin, JVM tuning, Machine learning or testability.

Open Spaces + Part @HEVRE, Beera Meiselsa 18 Street

Party

Party time!

Lunch - Room 3 (VEGE)

VEGE: Zucchini cutlets with tzatziki sauce + rice + salad

Lunch - Room 5 (Gluten free)

Grilled chicken in red pesto sauce + rice + salad

Lunch - Room 7

Grilled pork in green peppercorn sauce + boiled potatoes + salad

Lunch - Room 3 (VEGE)

Dumplings: Galician & Spinach + salad

Lunch - Room 5

Roasted turkey in capsicum sauce + rice + salad

Lunch - room 7 (Gluten free)

Roasted pork in parsnip sauce + boiled potatoes + salad

Lunch - room 7

L3_1

Lunch - room 5

L3_2

Lunch - room 3

L3_3

ID, EGO and Super EGO of your entity

Performance is one of the most valuable things you can do in programming. Most people think of performance as 'code speed', but there is the other, darker side. Performance as the ability to develop and maintain code over time. We will have a discussion about the handling of entity identifiers in common business applications. How does performance relate to how we identify entities? How can natural identifiers help? And what is the cost? Finally, we look at 'not so new' but still unpopular identity management solutions and their impact on performance.

Mastering GC: tame the beast and make it your best ally

Most of the time, We forget that GC exists because it handles memory on its own. But, unfortunately, it is often involved in production incidents. This is at that moment it reminds you it exists and not everything is magic! Moreover, OpenJDK brings a handful of GCs with different characteristics and the default one (well not always...) is not the easiest to understand. Though, this choice of GCs allows the JVM to adapt to different workloads and applications in terms of latency or throughput. I will explain how to tame those beasts and how to take advantage of them to improve your applications and resources.

Microservices or not? A dependency management decision

In my company Magnolia, in the Labs team, we have been exploring different ways to move our platform to the cloud. There are architecture decisions to look for, but the use cases and the domain is the same. We think starting with microservices is not a good approach because we are introducing complexity and a dependency that will make us develop much slower. With some of the best features of Java, such as interfaces and implementations, modules, testing, dependency management and Jakarta standards, we have created an application that can be deployed as a monolithic or as different microservices. We can deploy our application in different ways and test it at different levels. We will explore an example with different modules and connections between them. I will show the different ways you can test your modules. The code is in Java and uses Quarkus to deploy, but any JVM environment can be used. Finally, we will see all the benefits of using this modular approach to develop, test and deploy your applications.

A day in the life of a Quarkus developer

If you are a Java developer, chances are you’ve already heard about Quarkus. You may have heard about the developer joy that Quarkus provides. But what exactly is it? How does it enhance your day-to-day tasks? What benefits and shortcuts does it offer for your work? These are the questions we will address in this talk. During this live-coded session, we will create a new Quarkus project and demonstrate how it can expedite the development of Java microservices by leveraging its multitude of out-of-the-box features. The session will be interactive, so if there is something specific you want to see, we will gladly demonstrate it. Our primary focus, however, will be showcasing typical user application development scenarios, including database integration, remote connections using both blocking and asynchronous APIs, and implementing security measures. Naturally, we cannot overlook the crucial aspects of packaging applications into containers and deploying them to the cloud. Quarkus is a framework that places developer productivity as a top priority, fostering a sense of joy throughout the development process. You will witness the remarkable things we can achieve with Quarkus within the given time. By the end of the session, you will truly grasp the essence of Quarkus' development joy.

Reading code

As developers, we spend a lot of time learning to write code, while spending little to no time learning to read code. Meanwhile, we often spend more time reading code than actually writing it. Shouldn’t we be spending at least the same amount of time and effort improving this skill? Deliberate practice can help us get better at reading code. Learning how to better read and understand code, can in turn teach us what makes code readable. This might even help us to write code that is easier to read. In this talk we will discuss the benefits of deliberately practicing reading code in a code reading club or session without an IDE, as well as common strategies to navigate a new codebase and familiarise ourselves with the code using the IDE.

So You Think You Know Redis!

Redis. You love it. You need it. But how well do you really know it? Find out on the exciting new gameshow So You Think You Know Redis! where our host will challenge you to answer a series of questions about Redis. The first person to answer each question correctly wins a crappy American candy bar! On So You Think You Know Redis! you’ll learn things about Redis you might not know. Crazy things like how to set up circular lists, extract 13-bit integers, or add numbers with sorted sets. Tricky things like cache invalidation, cache eviction, and single-byte caches. Advanced things like persisting your data with Redis and extending Redis with modules. When we’re all done, you’ll walk away with a deeper knowledge of Redis and possibly that chocolate you desperately need. What’s not to love? Wanna find out? Join me as I explain what Redis is—a wicked-fast, memory-first database—and why you should care. I’ll share with you what it can store, how you can access it, and how you can make sure that what’s in memory is still there when the power goes off. We’ll explore how you can extend Redis—adding new commands, new data structures, and new capabilities. And, we’ll do it both from the command line and from code with examples in C#, Java, JavaScript, and Python. When we’re done, you’ll know what Redis is and what all the fuss was about. But, more importantly, you’ll know how to put memory first to build fast applications and faster experiences.

Native JSON Parsing, Operator Overloading and Insane features in Java?

Join this talk to learn about project Manifold. A free and open source Java extension that opens up the Java language to new capabilities. Do you want operator overloading in Java?
Proper parsing/generating of JSON, XML, CSV etc.?
Properties?
Scientific notations?
Extension classes?
More type safety?
Something better than var?
Typesafe reflection?
All of this and more is covered. This talk is based on my blog series on this subject: https://debugagent.com/series/manifold

Introduction and pitfalls of virtual threads

Java 21 releases one of the most anticipated features, virtual threads, and previews structured concurrency. It rethinks the way multithreading works in Java. It was born out of the idea that reactive Java is too complicated and blocking threads has to be cheap. Resulting in the new virtual threads that we run thousands of! The aim of virtual threads and structured concurrency is to have high-throughput lightweight threads and new programming models on the Java platform. In this talk, I will demonstrate virtual threads and how to create and manage them using structured concurrency. Furthermore, I'll provide some practical advice to avoid pitfalls when you start using virtual threads in your application.

Data-oriented Programming in Java

With the changes made to the Java language in recent releases, it has moved into a new realm: Data-oriented programming. In this talk, I will explain what data-oriented programming is and explain the principles it is based upon. When it comes to microservices, object-oriented programming is no longer the only paradigm in Java development. I will also show how recent language additions such as records, sealed classes, pattern matching, and switch functions support the concept of data-oriented programming. This will be done by using many code examples to explain how to migrate to data-oriented programming. In his June 2022 paper in InfoQ Java language architect Brian Goetz introduced the concept of data-oriented programming in Java (https://www.infoq.com/articles/data-oriented-programming-java/) While this may offer significant advantages, especially in the realm of microservices, much is still unknown. I will explain what the concepts are and how the Java language can be used.

Enriching Kafka Applications With Real-time Contextual Data

Developing high-performance large-stream processing applications is a challenging task. Choosing the right tool(s) is crucial to get the job done; as developers, we tend to focus on performance, simplicity, and cost. However, the cost becomes relatively high if we end up with two or more tools to do the same task. Simply put, you need to multiply development time, deployment time, and maintenance costs by the number of tools. Kafka is great for event streaming architectures, continuous data integration (ETL), and messaging systems of record (database). However, Kafka has some challenges, such as a complex architecture with many moving parts, it can’t be embedded, and it’s a centralized middleware, just like a database. Moreover, Kafka does not offer batch processing, and all intermediate steps are materialized to disk in Kafka. This leads to enormous disk space usage. In this talk, we will address these challenges and how real-time stream processing can be used to enhance Kafka pipelines by simplifying deployment and operations with ultra-low latency and a lightweight architecture making it a great tool for edge (restricted) environments. This talk aims to take your Kafka applications to the next level. The combination of Real-time storage and computing provides a unique synergy that enables applications to address real-time use cases at any scale.

Location transparency (for Java developers)

If it is the first time you've heard the term, then this talk is for you! If you are concerned about Coherence, Coupling, and Connascence metrics while building applications, this talk is definitely for you. If the amount of things that can break prevents you from splitting a monolith into distributed micro-services, then applying location transparency may be both your kick-starter and your safety net. In this talk, we'll examine a traditional application with its dependencies between methods, classes, packages, and modules. We'll talk about how those impact applications' ability to grow and be decomposed into independently deployable units. Then we'll see how and where to apply location transparency. Finally, we'll rise above the code to explore how Domain-Driven Design, CQRS, and Event Sourcing architectural concepts tackle complexity and why location transparency is key while doing so.

What can go wrong in a distributed system - experience from the field

Building a distributed system is a challenge that we have at Hazelcast. To build a distributed in-memory real-time computation and storage platform we use raw Java, with our RPC and concurrency stack, distributed primitives, replication and Raft-based consensus protocol. In this talk, on the example of our issues, we will discuss what you should care about while building a distributed system, and how one slow node can bring down the entire cluster even with the Raft consensus protocol.

Data Residency: the fun of storing data worldwide

Data Residency is a critical consideration in today's global IT landscapes. It involves the storage and location of data, which are subject to varying legal requirements depending on their physical whereabouts. Some jurisdictions even mandate data to be stored exclusively within their own borders. In this talk, we will delve into the intricacies of data residency, exploring its consequences for organizations operating across international boundaries. We will present various practical implementations of data residency, offering attendees a comprehensive understanding of the available strategies. Finally, by leveraging fully OpenSource projects from the Apache Foundation, we will showcase a sample implementation that demonstrates the feasibility of adopting such solutions.

Software 3.0: The Future of Software Development

The landscape of software development is evolving faster than ever before. Join us as we explore the future of software development in the era of AI coding assistants. In this talk, we'll make a compelling case for the shifting focus towards technical design and architecture. We'll look at how AI coding helpers are just the beginning and how they could become full-fledged teammates for developers, helping in the decision-making process; Important security concerns when using AI in software development; and practical advice on getting ready for the future, including learning about AI and promoting a culture of learning and experimentation. Discover why technical specifications matter in 2023 and how AI fits in, reshaping the way we create software. Learn how AI makes coding easier, freeing up time for developers to solve important problems. Find out how Software 3.0 empowers developers to be more creative and innovative.

Pattern Matching in Java Deep Dive

In recent years, pattern matching has been gradually introduced into the Java language. The pattern matching feature allows to take or not to take an action depending on whether an object in memory matches a given pattern or not. In this talk, we will start with review and demo the Java's journey to pattern matching so far. This includes pattern matching in instanceof and switch, and record (deconstruction) patterns. We will also show how to leverage the scoping rules for pattern variables. Then we will look at what are the options for future improvements of pattern matching for Java, and how future programs in Java might look like.

Object-centric processes - combining process modelling with OOP

In the world of web application development, two new fundamental concepts have emerged: 'all layers in one object' and 'process-driven programming' resulting in 'object-centric processes'. These principles revolutionize the way applications are built by simplifying development and enhancing collaboration. The idea of 'all layers in one object' revolves around encapsulating multiple layers of traditional full-stack architecture into a cohesive unit. By combining data, processes, and user interfaces within a single object, developers can streamline the development process and reduce complexity. This approach allows for a more intuitive and seamless integration of different objects, facilitating efficient communication and interaction. Process-driven programming introduces a lifecycle-based approach to objects, enabling developers to define and automate processes that govern application behaviour. By modelling business workflows as processes, developers can improve collaboration, enhance efficiency, and ensure consistent execution of critical tasks. This approach aligns application development with real-world processes, resulting in more reliable and scalable solutions. It is within this context that Petriflow, an open-source low-code language supported by the Netgrif low-code platform, enters the scene. By combining the principles of 'all layers in one object' and 'process-driven programming,' Petriflow provides 'object-centric processes', that offer a powerful and efficient solution for web application development. It embraces the concept of encapsulating all layers within a single object, simplifying development tasks and enhancing integration. Furthermore, Petriflow's 'object-centric processes' based on process-driven programming, allow developers to define and automate business workflows, improving collaboration and efficiency. Petriflow seamlessly compiles into Java on the backend, leveraging the robustness and scalability of the Java ecosystem. The lifecycle of Petriflow objects captured in object-centric processes uses the concept of tasks that have associated data attributes of the object. Petriflow provides events both on tasks and on data attributes. In addition to expressing relationships between objects using references to other objects in object-oriented programming, object-centric processes enable the synchronization of events in different objects. The compilation process bridges the high-level abstractions of Petriflow with the capabilities of Java, resulting in a powerful and efficient backend implementation. With Petriflow, developers can also leverage MongoDB for the data layer, ensuring flexible and scalable persistent data storage, and Angular for the GUI. In conclusion, Petriflow builds upon the foundational concepts of 'all layers in one object' and 'process-driven programming' resulting in “object-centric processes” to offer a comprehensive low-code solution for web application development. By combining these principles and seamlessly integrating with Java, MongoDB, and Angular, Petriflow empowers developers to create sophisticated applications efficiently and effectively.

How shit works: Databases

The last decade has seen a proliferation in data storage technologies, from MongoDB to ElasticSearch to Riak to Datomic and so many others: relational databases, document stores, key-value stores… oh my! So many choices, so much confusion. While fundamentally different products, all of these solve the same age-old problem: that of storing and managing data on a persistent medium. Yet despite using them every day, we are often confounded by how they operate, treating them as magical devices that require special care. No more! They say a little knowledge is a dangerous thing... care to find out?

Clean code, is it really worth it? A story about monsters, heroes and wins

As developers, we participate every day in our software life cycle adding new logic, adapting it, and integrating with services or platforms. But, do we put the same effort into making software robust, maintainable, consistent, secure, clear, and tested? In this session, I will show the need for good practices in Clean Code along with the issues of not using it, showing concepts like Clean As You Code (CAYC) using free and open-source tools. Clean Code goes beyond the produced software and its programming language. Is part of a developer's role growth no matter the language and the company

Embracing Microservices

Microservices have been around for a while, and the industry discovered myriad ways of failing to implement them. For example, due to suboptimal team compositions, attachment to old monolithic-friendly habits, poor deployment practices, grotesque corporate security policies, etc. In this talk, I will help you learn from others’ mistakes. We’ll recall the most important lessons learned from successful and miserable microservices implementations out there and focus on points that were not covered in similar talks.

Everything you always wanted to know about mainframes (but were afraid to ask)

Your last credit card payment was most likely processed by a mainframe. Although still alive and well, mainframes are an entire different world unknown to most Java developers - besides jokes about dinosaurs. They offer a peculiar mix of old and modern features, backward compatible with punch cards but supporting many cutting-edge technologies (including Java). I will start with an entertaining tour of the mainframe programming environments (Cobol, JCL, and much worse) and highlight the main differences with the tools you're used to. Then I'll discuss the dilemma with mainframes, why people want to stick with it but at the same time want to move away from it. I'll finish with an overview of legacy modernization techniques.

The Emperor Has No Docs

Software, like board games, needs instructions. Should I draw a card or play my card first? Will the connection be reused, or should I use a connection pool? In heroic tales, a protagonist needs directions from elder scrolls to user magical artifacts and complete their mission. In this talk, Ignasi will explain his journey from neglecting docs to considering them an important step on the software delivery cycle. Ignasi will share tips ant tricks he’s been collecting over the years and focus on which habits he adopted to make sure he doesn’t forget docs. Ignasi will also share the types of audience and cases where documentation can save time and money to your organization. After discussing the importance of documentation within several teams, Ignasi will try to counter the usual arguments and excuses those who don’t document often use. No, the code is not the documentation, the code doesn’t tell the whole story. You can have a strong type system restricting how to call an API and still be an unusable API: “Hmm, I need a Token here, where do I get it?”. Join Ignasi for a talk about board games, child tales, and embarrassing PRs. This talk targets beginner/daily user/experts alike.

Building Your Own Bot with GPT: Harnessing the Power of AI for Personalized Conversations

OpenAI's GPT-based language models have made it easy to build conversational agents that can respond to a wide range of queries. However, these models are not trained on personal data, which limits their ability to provide tailored responses. This talk will focus on how to leverage OpenAI's APIs to build a personal chatbot that can provide personalized responses based on an individual's data. We will explore the technical aspects of building a custom data set and “training” a GPT-based model using OpenAI's API, and explore various strategies that can be used to improve the performance of the chatbot.

Mastering Java Persistence: Best Practices for Cloud-Native Applications and Modernization

Join us for an insightful presentation as we explore the world of Java persistence in the context of cloud-native applications and modernization. Discover the fundamental principles, challenges, and strategies. From uncovering database patterns to harnessing the power of cloud-native technologies, this session will provide valuable insights for developers, engineers, and architects seeking to optimize their application's persistence layer. Take advantage of this opportunity to better understand how to create maintainable architectures, tackle data integration challenges, and embark on successful modernization journeys. Whether you're new to the concept or looking to enhance your expertise, this presentation is your guide to mastering Java persistence for the future of software development.

Let's adopt the `clean archigonal`

After a period of stammering where we coded as best we could, we believed, after the 2000s, to have found the ideal architecture: a division into layers, where each would have a dedicated responsibility. Attractive idea on paper, effective implementation... at first. In order to overcome these problems, architectures have emerged, including the Clean architecture and the Hexagonal architecture. But:

GraalVM, CRaC, Leyden and friends - in search of TRULY cloud-native Java

Although the term 'Cloud Native' in the context of Java has been repeated ad nauseam for years, the JVM as a platform has only recently entered a phase where everything truly aligns with how cloud-native architectures are designed. Let's trace the path Java has already taken in recent years and take a look at what lies ahead in the future. During this presentation, you will learn about projects such as Leyden, CRaC, and GraalVM, and how they can realistically influence the way applications are developed. It turns out that these projects intersect and collectively provide a broader context for the direction Java is evolving in.

Progressive Delivery in the Kubernetes era

Production is the place where all applications should live. Even though you are using continuous integration and delivery, you might wonder every time you release a new version to production if it will work or there will be some breakage on the latest version, eventually making production unavailable to the customers. Progressive delivery is the next step after Continuous Delivery to test your application in production before it becomes fully available to all your user bases. Embrace progressive delivery with techniques like the blue-green, canary release, shadowing traffic, or dark launches to validate the application in production using Kubernetes and tools like Istio, Prometheus, ArgoCD, or Argo Rollouts. Come to this session to learn progressive delivery in action using Kubernetes.

Your Cloud-Native Toolbox for Java

What does it mean to have cloud-native Java applications? What do you need to think about to be a good Cloud citizen? It is not about the platform you run it on or the library/framework you want to use. It is about how you build scalable, observable, resilient applications while keeping in mind the application architecture, containers, builds, testing, automation, and standards. Join us in exploring different tools for creating cloud-native Java apps. We will go through the whole life-cycle of an application – from the first lines of code to a fully operational and containerized application.

Thinking in Serverless Java (Code)

Compilable and sharable infrastructure with Infrastructure as Code, Self-provisioned runtimes, great IDE support, energy, and CO2 savings - Java is the perfect language and runtime for serverless cloud environments. In this talk, I will discuss the key differences between serverless Java and monolithic (but great!) application servers and microprofile runtimes with lots of code and live deployments. We will start with synchronous, monolithic functions and conclude with pragmatic Event-Driven Architectures and 'no code' ...still with Java. Your questions are highly appreciated!

Turn your Java library into low-code/no-code system

The goal of Enso (http://enso.org) is to provide low-code or even no-code system for obtaining data insights easily. The fact that Enso runtime is fully implemented in Java however opens completely new opportunities which we are going to explore in this talk. Enso provides an excellent interoperability capabilities with Java and that makes it an ideal 'wrapper' around any Java library. This presentation is going to demonstrate the power of Enso and will share simple tips and tricks to turn any Java library into an Enso component. With the help of scalable, slick and performant Enso IDE we demonstrate completely new approach to development suitable for beginners, Excel power users and anyone who cares more about analyzing data than coding the best algorithm in a low level programming language. Package your favorite Java library for Enso. Make it easily approachable for non-programmers!

Deterministic systems: Why and how-to?

We will walk through a pattern for deterministic code execution, how you can put in into practice and the substantial benefits this brings you as a developer. LMAX runs a financial exchange where the core of the system is a matching engine - a giant state machine. For a matching engine, or any state machine, ensuring that you can mutate it in a deterministic manner is key. Is reliability, easy system recovery and focus on writing (probably) the fastest Java code in the world on your list of interests? Join us to see how a single decision changed the way we reason about code and problems we solve, and made our lives easier!

OAuth and beyond: Modern auth not only for the web

The OAuth2 framework has been widely used for over a decade, but many take it for granted without really understanding it. In our talk, we will try to change that. We’ll go through why OAuth came to be and what problems it solves, describe the basic authorization flows and how they prevent various attacks. A special part will be dedicated to scenarios where the user authenticates to a device that lacks input / output capabilities. We’ll contrast OAuth to OpenID Connect (OIDC) specification, show how authorization is different from authentication and how we use this distinction to our advantage. Finally, you will see how modern web allows you to go passwordless using Fido2 and Webauthn. Our talk will be beginner-friendly with practical demonstrations.

Unleash the power of your applications with Micronaut and GraalVM

In this talk, Juarez Junior, will demonstrate how you can quickly build optimised Microservices with Micronaut & GraalVM Native Image. Attendees will learn how the combination of GraalVM Native Image and Micronaut can lead to efficient, highly performant, and optimised applications that can be perfectly deployed to environments like Kubernetes or serverless platforms. There will be a live coding demo of an application using Micronaut Data and GraalVM.

Patterns & Practices of Implementing Event-driven Microservices

Event-Driven Microservices architecture has gained a lot of attention recently. The trend in the industry is for Microservices to innovate faster. While Microservices have their benefits, implementing them is hard. One drawback is the problem of distributed data management, as each Microservice has its own database. Event-Driven Architecture enables a way to make microservices work together and the talks show how to use architectural patterns like Event Sourcing & CQRS. Another challenge is to manage transactions that update entities owned by multiple services in an eventually consistent fashion. This challenge is solved using sagas! The objective of the talk is to show how to implement highly distributed Event Driven Microservices architecture that are scalable and easy to maintain.

The dark side of kotlin

About experimental, new, and less known but controversial kotlin features or how to write the code so clean that it is hardly understandable, and would anyone do that? In the talk: coroutines, receivers, context receivers, extension methods, and other horrors.

AI, Determinism, Code Generation and Refactoring (Room 9)

At this point, we are past the initial hype cycle of AI. Many of us have tried to figure out where AI tools fit in the development process.Initially there were hopes and fears that we could easily generate code from prompts and have AI tools perform unguided refactoring. The truth is, AI tools aren’t fully capable of those tasks but they can still be useful. In this keynote, Michael Feathers will talk about the current state of AI usage, practices he has found useful and directions all of this might go.

Avoiding mistakes with events, one event at a time

Some say: Use events, events are great, all will be great and rosy. Then reality bites, and.. let's talk about strangers you'd rather avoid - mistakes to make when building using events. Things change, evolve, are not and overdelivered, old events start taking a lot of space, and someone is already using the name you wanted?! Expect: problems, symptoms, consequences, and some 'get-out-of' cards. Come for the experience others gained first-hand, so you know what to avoid.

Machine Intelligence With Humans in Mind

We are in a rapidly changing world of globalization and digitalization, where computer ethics has become significantly important. Machine intelligence is growing in a way that is difficult for humans to comprehend and even more challenging to control. Focus on computer ethics goes beyond protecting personal and commercial information. What are the responsibilities of companies, developers, and users, and how can we overcome the lack of awareness of computer ethics? In this talk, we will look at the importance of computer ethics in our daily life as tech people and as users in the digital world and how we can start taking action.

Databaseless High-Performance Persistence with EclipseStore: 1000x Faster Queries at 98% Cloud Cost Savings

Hibernate is the de facto standard persistence for relational database applications in Java. Both were built for monolithic applications and worked quite well so far. EclipseStore (formerly MicroStream) was built to become the new Java persistence for next-generation enterprise applications, containerized microservices, and serverless infrastructure. EclipseStore is a revolutionary databaseless persistence approach. The idea behind the project is: build any Java app, process data in the memory by using Core Java only, your Java environment cares for persistence full-automated like magic. Just use a cloud object storage such as AWS S3 or plain file storage instead. The high complexity of external database systems, mappings, schema migration, caching and database clusters is eliminated. An external database system is not required at all. A cloud object sotrage such as AWS S3 or even plain files are used instead. There are 3 major benefits: 1) high performance in-memory data processing, up to 1000x faster queries compared to JPA, microsecond response time, gigantic workloads. 2) 98% database cost savings in the cloud. 3) Revolutionary simple architecture and implementation, Core Java features only, higher developer joy and productivity, and faster time to market. In this session, you will learn how EclipseStore works, what’s new, and how you can build distributed, elastic scale-to-zero cloud-native apps and microservice based on Kubernetes, just by a simple JAR deployment.

Get Started Coding with EclipseStore and Build Ultra-fast In-Memory Database Apps and Elastic Scaleable Microservies on Kubernetes

EclipseStore (formerly MicroStream) was built to become the new Java persistence for next-generation enterprise applications, containerized microservices, and serverless infrastructure. In this session, you will learn how to get started coding with EclipseStore. EclipseStore is a revolutionary databaseless persistence approach. The idea behind the project is: build any Java app, process data in the memory by using Core Java only, your Java environment cares for persistence full-automated like magic. Just use a cloud object storage such as AWS S3 or plain file storage instead. The high complexity of external database systems, mappings, schema migration, caching and database clusters is eliminated. An external database system is not required at all. A cloud object sotrage such as AWS S3 or even plain files are used instead. There are 3 major benefits: 1) high performance in-memory data processing, up to 1000x faster queries compared to JPA, microsecond response time, gigantic workloads. 2) 98% database cost savings in the cloud. 3) Revolutionary simple architecture and implementation, Core Java features only, higher developer joy and productivity, and faster time to market.

Where Did All the Fun Go?

Bogomil's career in IT started as a servant to programmers: fixing a line or two in the code, and now he is a Director in a vast international privacy company. When he looks back, it was different. Oh gosh, we had so much fun in the past. It seems that at some point recently, most of the world decided that IT is an elite profession that needs to produce only value no matter what. This is a great tragedy, and it must be rectified. Why do we have feelings, emotions, and personalities if we no longer have fun? In this talk, we'll take a retrospective journey through the years to what went wrong and how we fix it together. We will cover the epoch of the world before Agile to the era of the Artificial Immigrant(AI), who is here to take your jobs away. This session comes with a bit of a heavy metal music.

Serverless Java hacks: Think different and leave old habits behind

In this presentation, we will delve into the details of developing serverless applications in Java, emphasizing the need for a paradigm shift in coding practices and architectural considerations. I will explain key aspects of serverless Java, including source code structuring, framework choices (many of them based on Jakarta EE), deployment strategies tailored for serverless environments, and runtime optimizations with GraalVM native compilation and tools like CRaC and AWS Snapstart. Serverless applications require precise attention to startup speed optimizations and efficient resource initialization. We will discuss strategies for resource management, advocating for lean connection and thread pools. Additionally, we will examine the importance of external configuration, statelessness, and the efficient storage of state data in external services or databases within the context of serverless architectures. As part of our technical exploration, I will highlight the advantages of using specialized client libraries optimized for startup speed, in contrast to traditional libraries designed for high throughput. By the end of this session, you will gain a deep understanding of the technical nuances involved in serverless Java development, equipping you with the tools and insights needed to optimize performance and seamlessly adapt to serverless computing environments.

GraalVM Scripting Languages as Maven Dependencies

The GraalVM project serves as an umbrella for a diverse set of interesting technologies, all built around the GraalVM compiler. The most well-known at this time is the GraalVM native-image tool. However, there is also the GraalVM JIT compiler, a drop-in replacement for HotSpot's C2 compiler, and implementations of additional GraalVM languages such as the Python (GraalPy) and JavaScript (GraalJS). These additional GraalVM languages can be used as standalone distributions or through a Java embedding API, allowing for the extension of Java applications with these languages. For instance, you can offer Python scripting capabilities to users of your Java application. Even if such an application is compiled with native-image, it retains the ability to dynamically load, execute, and even JIT compile Python scripts. With its recent release, the GraalVM project was restructured, decoupling the additional languages from its core. We now have the GraalVM JDK distribution, which is an OpenJDK build enhanced with native-image, and the additional languages are delivered as Maven dependencies, compatible not only with GraalVM JDK but also with OpenJDK and OracleJDK, albeit with some caveats. In this session, we will explore how to use GraalVM languages as Maven dependencies and showcase their potential to enhance Java applications.

Falling in love with json(net)

JSON is a piece of technology clearly involving simultaneous or alternating emotions of love and hate. Mostly hate. At the same time people (over)use it everywhere. Kubernetes cluster configuration - checked. Grafana (or any other monitoring) dashboard - checked. Managing AWS account permissions - checked. At the same time, we strive for infrastructure as code so the codebase keeps growing and growing with copy-and-paste 'templates' managed via string replacement. But we can do better. In this short talk I'd like to take you to the world of jsonnet - a configuration language not just a data format. We will walk through the basics and see how to keep sanity when working with configurations.

Let’s dive into the topic of testability

In order to be able to test something, you want to be aware of potential pitfalls. Many of these pitfalls can be mitigated as long as you know how. This is a highly contextual area. Sometimes you can test in isolation, sometimes you need to prepare half of the world in the proper state in order to be able to perform a reasonable test. We will look at some examples that may cause you some headache
* Time - how do you write a test that includes time passing in a fast unit test?
* Randomness - how can you test something that includes random values for basic correctness?
* Expensive collaborators - how do make sure your system can be verified without calling a third party payment gateway? There may even be a few war stories… This topic is large so we will only be able to scratch the surface during a lightning talk. Nevertheless, you will get some ideas on how to approach some problems when you face them. Most importantly, you know that there is probably a solution, now you just have to find it.

Simplifying Polyglot Persistence Integration with Jakarta Data: A Hands-on Approach

In the ever-evolving world of Java enterprise applications, efficient data integration is key for robust and scalable apps. This session introduces Jakarta Data, a groundbreaking Jakarta EE specification designed to transform the way we handle data. Discover how this robust framework: - Simplifies data integration processes. - Bridges various Jakarta EE technologies. - Promotes the polyglot persistence. With its ability to easily engage with a range of database styles, Jakarta Data ensures developers can prioritize core business strategies, paving the way for faster application development. Our exploration will cover the capabilities and advantages of Jakarta Data, showcasing its application in contemporary enterprise structures. Whether you’re dealing with relational databases or venturing into document-based NoSQL solutions, learn why Jakarta Data, with its adaptable and open-source attributes, is an indispensable tool for Java developers. Let's explore various strategies to tackle this issue, from eager loading to batching preferences and manual entity loading. By the end of this talk, you'll be equipped with actionable insights to optimize your ORM interactions and ensure efficient data retrieval.

Feeding the ML model with data from the database

In today's fast-paced business environment, organizations are constantly seeking ways to derive actionable insights from their data as quickly as possible. ML models are capable of doing that. However, implementing a complete ML pipeline can be quite challenging, especially if you want to process newly arrived data immediately or you have a legacy system which is hard to connect with your modern infrastructure . Change Data Capture (CDC) has emerged as a technology for delivering real-time data changes from various sources, especially from the databases. In this talk we will introduce Debezium (https://debezium.io) a leading open source framework for CDC. We will discuss how it can be leveraged for ingesting data from the various databases into ML frameworks like TensorFlow and what the pitfalls are if you go this route. Attendees will gain a deeper understanding of how Debezium CDC works, how it can help them to ingest data from the source database into the ML framework in real time and also what are the possible challenges with this approach.

Frameworks Unplugged: Building Distributed Systems in Pure Java

Building a hello-world REST example in spring-boot does not take more than a couple of minutes. ChatGPT generates it within seconds (including the maven files), and the example will probably let you pass java programming 101. You can ask ChatGPT to add a distributed cache to your application, and it will provide a good recipe for embedding Hazelcast into your java solution. The same goes for database access, choosing a persistence framework, etc. These are becoming everyday, menial tasks a supervised machine can perform independently. Does this mean software engineering is in decline, developers are no longer needed, and we should look for a new job? And this presentation will be about carpentry? Nope. When we ask the computer how do the REST endpoints work? What are the standard HTTP methods such as GET, POST, PUT, DELETE, and how does the computer know which method I'm calling - the responses become vaguer and vaguer. How does a distributed system know its state, and how do clusters discover members? These are trickier questions, and one needs to know what to ask for. So there is a chance for us. We still have a role to play in this engineering wishy-washy. We need to understand the basics which support the frameworks we use daily - and that's what we will focus on during this session. Not just by scratching a surface, not by an academic lecture. We will dive into the code and implement a simple cluster, distributed system replicating data over the network. No frameworks, just Java code and principles, definitions and algorithms underlying our everyday work. What can possibly go wrong?