From language models to intelligent agents

Language models such as GPT-3 and its successors continue to amaze us with their ever-expanding capabilities. However, what if we take things a step further by allowing these models to access data from various databases and granting them access to an array of tools such as web browsers, IDEs, and APIs? In this scenario, a language model could potentially become a genuine intelligent agent that can receive information from its environment, make decisions based on that information, and take actions that affect its surroundings.

During my talk, I will discuss a draft architecture for intelligent agents, as well as several recently developed tools that have made the development of such agents much more accessible. By leveraging these tools and resources, we can create intelligent agents that can assist us with complex tasks, streamline our workflows, and even automate entire processes.

Coffee break

Log4Shell restrospective

It's been one and a half years: Let look behind the immediate pain of Java's now infamous logging library Log4j — what happened, how, and why it's still relevant.

• How does the vulnerability work and why was it so special?
• Why is it relatively complex to detect and evaluate for both custom and off-the-shelf software?
• How can you monitor exploitation attempts?
• Can we avoid the next one?

Virtual Threads in action!

Helidon Níma has become the world’s first web framework which is by design based on Virtual threads – one of the major gamechanger in the industry. Virtual Threads, first in research Project Loom and now as a preview feature in JDK19+, dramatically change the resource usage in the JVM, allowing achieving performance comparing to reactive engines, but with fully blocking paradigm. In this talk I am going to tell you the story of Helidon Níma – what were the problems and what were the solutions, what tasks it is designed to work on, and why it has changed the world of web frameworks.

Break

(Friendly) coexistence between product designers and developers

Designers: 'Developers won't code, what we have drawn'.

Developers: 'Designers draw things, and it makes no sense to actually develop them.'

How can we speak a language we both understand, and together create solutions based on user needs?

Why and How to Upgrade to Java 17 (and Prepare for 21)

Java upgrades are sometimes seen as difficult and many applications are still running on an older version of Java. This session describes Java's current six months release process and why applications should use a recent Java version. After that, I'll explain the challenges of upgrading and provide some useful tips to make the process easier. Concrete examples (including solutions) will be used to show you what changed in which version of Java and how to handle the changes. After this session you're ready to upgrade your applications to Java 17 and prepare for Java 21.

Coffee break

What every Java developer needs to know about Serverless

Due to the savings it provides, serverless architecture ends up being a very relevant option to be used in the cloud or on-premises. Therefore, sooner or later you will come across this type of architecture at your work or in a new opportunity. But many people, when thinking about serverless, dismiss Java as an option. However, Java is an excellent choice for you to create a serverless application. Get inside the serverless architecture and learn how the Java ecosystem has evolved to be a great fit for this scenario. Having this knowledge will prepare you for serverless architecture without requiring you to learn any new languages.

Chopping the monolith

Micro services are ubiquitous. However, most companies that implement micro services do not reap their full benefits - at best. At worst, it’s an epic failure.

There are reasons for micro services: independent deployment of business capabilities. However, the unspoken assumption is that you need to deploy all capabilities all the time. My experience has shown me that it’s plain wrong. Some capabilities need frequent deployment, while some are much more stable. In “the past”, we used Rule Engines to allow updating business rules without deployment. While it solved the problem, this approach had issues. Between introducing a Rule Engine and migrating your complete system to micro services, I believe that there’s a middle path, and that this path is Function-as-a-Service.

In this talk, I’ll detail every point I’ve made above, and show how one can use Serverless to pragmatically design a system that allows deploying as often as you need.

Break

In-Memory Computing - The Big Picture

Modern software systems must process tons of data and must provide low latency responsiveness to be able to compete. We've known for a long time that traditional databases cannot keep pace. In-memory computing is incredibly faster. Therefore, in-memory concepts have been added at every nook and cranny. However, is it enough just to use some in-memory computing? Are there differences? Is it sufficient to simply use a cache? Are there pitfalls? When should I use a distributed cache? Is an in-memory database the better approach? What is actually an in-memory data grid?

In this session, you learn the basics and get a better overview to make a decision that fits your project and team.

Under the hood: tricks, hacks and techniques that make Quarkus so enjoyable and fast

When we talk about Quarkus, we generally mention what a great platform it is for micro-services, or web applications, and we show how much effort went into the developer experience and all the fancy things it does to make you more productive and happier. Well, this talk isn’t about that. This talk explains how Quarkus achieves that. This talk will explain the challenges we faced when developing Quarkus and all those times where we pushed the boundaries of what it was possible to do, just to make our user’s lives easier. We will talk about bytecode scanning, indexing, modification, working around Java language and bytecode limitations, generating native code, as well as elegant or hacky techniques employed by Quarkus to solve interesting problems. Come to see how the magic is made: behind the scenes. You may be amazed, or scared, but you’re bound to learn a thing or two ?.

Lunch

Jakarta EE: Success comes with building strong open source community

The future of enterprise Java application development is in good hands with Jakarta EE! Jakarta EE 10 is the first major release with community driven innovations, and it all started with building a strong open source community committed and excited about the technology. In this session you will learn how to become part of the community and get involved; you will learn about the Jakarta EE 10 and plans for the future. This presentation will provide you with key insights into the industry-wide, open source collaboration to modernize Java enterprise systems for cloud-centric use cases. This is a beginner session designed to provide the status of the popular framework and inspire participation in the project and open source development.

From (enterprise) analysis to (sustainable) implementation with OpenAPI (and tools)

Enterprise software must capture and enable the characteristics of business. This often means complex rules, hairy and very nuanced data models accompanied by an overwhelming and diffused boredom. The same is true for implementation whereby keeping the focus and the energy necessary to coordinate various teams working on a complex enterprise system is not an easy task. Using the OpenAPI standards, its tools and building some tools ourselves, we have been able to build a value chain of software development that keeps API designers, backend and frontend developers engaged on the same page and free as possible of boring work. All while producing working and tested software in a sustainable (and sustained) pace. We want to share our story to help you evaluate if these methods can help your organization to collaborate and work better and more effectively.

Coffee break

Adaptive JVM (GC) Threading: The Goldilocks Dilemma with Parallelism

Through this session, the audience will get an under-the-hood look at OpenJ9 JVM/GC technology, they will be exposed to innovations in the JVM space, and overall gain a better understanding of the implications of GC on application performance by exploring a cool new optimization - Adaptive Threading!

This session intends to take a deep dive into Eclipse OpenJ9 JVM/GC internals, it first lays out the basics of GC and builds upon them to explore performance. The presentation will heavily focus on GC parallelism and Adaptive Threading, a new innovative GC optimization for self-tuning parallelism to minimize application pause times. The role of parallelism in reducing pause times and the way in which GC tasks are parallelized to take advantage of available resources are explored. The audience will see the effects of GC parallelism on performance and observe how parallelism can be unexpectedly detrimental to performance. The session then shifts focus onto Adaptive Threading and signifies the need to develop an optimization for self-tuning GC threading/parallelism. We explore how Adaptive Threading aims to find the “goldilocks” or equilibrium number of threads, where GC achieves peak performance through parallelism. With the use of heuristics and a threading model, an optimal thread count can be projected, and the thread count can be adjusted dynamically between GC cycles to minimize inefficient use of threads. The presentation showcases how this cannot be done trivially; accurate decisions must be made to determine when to adjust the thread count, and how much to adjust by.

Security: An Inconvenient Truth

There are security minded people. They have a password manager, and unique, strong, passwords for each account. They dutifully lock my computer each time they leave it alone. But there are others. For these people 'Security' is an ugly word. They skirt policies any way they can, leaving post-it's with 'Welcome123' in their wake. Worse, these aren't only users of your software. They're sometimes colleagues! These are people that value convenience over security. In this talk, I get in the mindset of the convenience minded person and try to find solutions that bring security and convenience together.

Break

Java's Hidden Gems: Tools and Libraries

This session is a whirlwind tour of many lesser known, but very interesting, Java tools and libraries. We'll have a sneak peak at dozens of tools to improve security, builds, architecture, tests and other areas. After this session you'll surely have learned something new, which you can further investigate whenever you want to apply it.

Deploying apps the GitOps way with ArgoCD

GitOps has been around for quite some time now, so there was plenty of time for the tooling to get mature. On this lecture we'll be exploring ArgoCD which graduated graduated CNCF on December 6th 2022. We'll go through the basic concepts and the various benefits/features that it offers.

Break

Cool things you can do with Quarkus

In this talk, Matej, Tomaž and Aleš will each present their favourite Quarkus feature as a demo. Attend this session to see what Quarkus users like.

Modern Gradle

The notion of developer productivity is a key subject in our increasingly computerized society. It seems consistent to apply the same software engineering practices to the build as for your applications and libraries. And with the recent evolution of Gradle, you can apply the same good software engineering practices from your applications to your build.

In this talk, we will first take a quick peek into the features that make Gradle shine. Through work avoidance, parallelization, and caching, you will see how Gradle keeps build time low even for complex projects and how this can significantly impact development workflow for you and your team.

After that, we will focus on the structure of your project. You will learn how to organize build logic, making it reusable and convention-based. You will also learn a bit about hot Gradle topics like:

• Kotlin DSL
• Toolchains
• Version catalog
• Configuration cache and maybe more.

Finally, we will discuss the next topics on Gradle's roadmap.

How to reduce configuration duplication across services using Gradle plugins

It's Monday and you're back at work. It's time to add another microservice to your steadily growing group of backend services. What fun! It's a greenfield project, so you get to avoid all the legacy code. But wait! This also means you have to reimplement all the configurations for your microservice. You think fondly of Maven, where you can use parent POMs to store common configurations and Maven archetypes to generate project templates. But then you remember that someone moved everything to Gradle many moons ago and now you have to use it in favor of Maven… Nothing like that is available in Gradle. Suddenly, you're overflowing with frustration. You see your boss walking towards your desk. Your hand reaches for the stapler, the first heavy, blunt object in your reach...

If this is you, fear not! I may have a solution. In this presentation, we'll look at how we use custom Gradle plugins at Outfit7 to encapsulate common configurations across our microservices to reduce configuration duplication and make it easier for anyone in the team to set up a service that fits with our guidelines. And all without having to spend hours browsing the web to find documentation on the obscure plugins we use. Instead, they just spend hours browsing our internal Confluence pages. Achievement unlocked!

All attendee party

The all-attendee party will take place on the beach Meduza, just across the Hotel Slovenija. 

We will kick it off with a nice beer selection from Pivovarna Pelicon, including beers:

• Yes Boss!
• Session IPA
• Blonde ALE

In the background DJ Jaka will spin music and Sam Sebastian, one of the greatest magicians will perform some of the tricks that even ChatGPT cannot understand :-)

Eclipse MicroStream - Ultra-fast Java cloud-native persistence for microservices and serverless apps

Hibernate is the de facto standard persistence framework for traditional Java database applications. Now, Eclipse MicroStream was built to be the Java persistence for containerized microservices and serverless functions. Eclipse MicroStream follows the system prevalence architectural pattern. The engine enables seamlessly storing any Java objects of any size and complexity transaction-save into cloud-native blob stores such as AWS S3 or any other binary storage. ACID transactions are journaled and deltas of the system state are regularly saved to disk. To reduce startup time and run also with a small RAM capacity of under 1 GB, MicroStream provides lazy loading. With Java Streams API, queries are executed in memory in microseconds - way faster than comparable JPA queries. Implementing is simple. There are no requirements for the entity classes, no annotations, interfaces, or superclasses, just POJOs. Additionally, expensive mappings or any data conversions are eliminated. The core benefits are extremely high performance, simple implementation, running trouble-free with stateless microservices, and reduced cloud storage costs.

Predstavitev orodja za razvoj cloud native rešitev Micronaut

Predavanje je namenjeno predstavitvi orodja Micronaut, ki ga v konzorciju podjetij Micronaut Foundation razvijamo in je namenjen razvoju in testiranju različnih vrst aplikacij kot so cloud-native mikrostoritve, aplikacij, ki jih poganjamo z ukazne vrstice kot tudi velikih monolitnih aplikacij. V ta konzorciju so glavni partnerji ObjectComputing Inc. (za katerega delam jaz), Google, Amazon, Microsoft in pa Oracle Inc., ki je pred letom dni postal inženiring partner. Micronaut odlikuje izredno kratek zagonski čas aplikacije in manjša poraba pomnilniških in procesorskih resursov, kot ostala primerljiva orodja.

Ker je Micronaut orodje, ki v celoti podpira cloud-native principe, so cloud-native lastnosti kot so service discovery ter configuration management kot tudi možnost poganjanja Micronaut aplikacij v okoljih kot sta Google Cloud Run ter AWS Lambda del orodja in so podpre v vseh glavnih cloud okoljih (Amazon Web Services, Google Cloud, Oracle Cloud Infrastructure ter Microsoft Azul). Programski jeziki, ki jih Micronaut podpira so Java, Kotlin ter Groovy, kar omogoča razvijalcem, da uporabijo programski jezik, v katerem se najlažje izražajo. Micronaut ima prav tako vgrajeno podporo za različne sporočilne sisteme (Kafka, RabbitMQ) in podatkovne zbirke (Oracle, Postgres, MongoDB, Redis in drugi) ter v celoti podpira Hibernate ORM ter JPA.

Zaradi hitrega zagona je pisanje testov oziroma TDD (test driven development) pristop k razvoju aplikacij še posebej zanimiv oziroma olajšan saj lahko enostavno testiramo celotno aplikacijo oziroma izvajamo integracijske teste v času, ki smo ga prej porabili za unit teste. Ker Micronaut za pripravo svoje infrastrukture ne uporablja Java Reflection je vsaka Micronaut aplikacija pripravljena za uporabo GraalVM prevajalnika, kar pomeni, da jo enostavno prevedemo v binarno obliko in jo lahko izvajamo brez uporabe JVM (Java Virtual Machine) V predavanje je vključen tudi kratek prikaz razvoja aplikacije z orodjem Micronaut.

Coffee break

Kubernetes Gateway API

Come to this talk to learn what is Kubernetes Gateway API.

Micronaut Framework and Microstream Java-native persistence engine

Sergio del Amo introduces Microstream integration with the Micronaut® Framework in this session.

Microstream is an Object-Graph Persistence solution that allows ultra-fast in-memory data processing with pure Java.

MicroStream is a Java-native object graph persistence engine for storing any complex Java object graph or any single subgraph and restoring it in RAM at any time by using a fundamentally new serialization concept designed from scratch. With MicroStream, you can restore in RAM on demand the entire object graph, partial subgraphs, or only single objects. Beyond serialization, MicroStream is ACID transaction safe, can handle your class changes and provides a garbage collector for the storage, multi-threaded IO, and connectors for various data storages. This session will teach you how to use Microstream as your persistence engine in a Micronaut Application. Micronaut Microstream integration allows you to run several Microstream instances in the sample application, simplifies configuration, storage operations, metrics, health, etc.

Moreover, you can use Microstream as a cache implementation for the Micronaut Framework.

Attendees will discover how the Micronaut Framework and Microstream are a perfect combination to build ultra-fast applications without leaving the confines of Java.

Break

Hibernate ORM, 20 years later

Hibernate is the preeminent object/relational mapping solution, and is still immensely popular two decades after it was first introduced to the Java community. The Hibernate team recently had an opportunity to ask what Hibernate got wrong, and what could be done about it. Answers to those questions were realized in Hibernate 6, which marks a significant break with the past. Simultaneously, the needs of Quarkus pushed the team to create Hibernate Reactive, the first non-blocking ORM. In this session, Gavin King will talk about Hibernate 6 and Hibernate Reactive, and of his experience returning to the world of data access after a long absence.

Break

End-to-End Data Engineering with Google Cloud

Data engineering is the process of designing, building, and maintaining data pipelines to ensure that data is available for analysis. Data engineering is a critical part of any data science or machine learning project, and it requires a deep understanding of the different tools and technologies available.

In this session, we will provide an overview of the different Google Cloud products that can be used to build end-to-end data engineering pipelines - from Pub/Sub for message ingestion to Dataflow and Dataproc for data processing, BigQuery for data analytics to Looker for data visualization.

Finally, we will discuss how to use Vertex AI to build machine learning models that can be used to make predictions and recommendations.

Introduction and pitfalls of Java's new concurrency model

Java 20 will preview one of the most anticipated features, virtual threads, and 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.

Lunch

Let's talk Frameworks [PANEL]

This panel will be an overview of the three biggest Java frameworks: Quarkus, Spring Boot and Micronaut.

Guest speakers are:

• Gavin King, IBM
• Roman Naglič, Object Computing Inc.
• Etien Roznik, Sportradar

Panel will be moderated by Oto Brglez. 

Coffee break

"How I beat The Lady Luck?" - Why software developers need side project(s)?

Most of us as software developers have something called a "Main Job", which we do to earn money, provide for our family, take care of our needs. In many cases, the main job may not be according to our desire and control. So what happens to passion and desire to learn something new? That's where a “Side Project” comes in. A “Side Project” is something you do in addition to your main job to fuel your passion to learn something new. It has several benefits such as: living your passion, learning new skills, potential for growth, boosting your mental health, etc. The goal of this presentation is to show what you can do in four, five evenings and enrich your experience. The idea came while I was watching the Eurovision Song Contest with my friends. I wanted to be ahead by knowing who the favourites and possible winners are. The presentation will answer some questions such as: what was the trigger, how to develop your idea, what is needed to make it happen and finally the conclusion.

The Next Generation of Datastores: Hot Queries, Cold Storage

The architecture of datastores has recently added a new trick: relying on blob stores. It offers new possibilities in scale, cost, and operational simplicity by building on the current storage standard of our industry — AWS S3. But of course, it comes with tradeoffs. This talk gives an overview of: * How do blob stores fit into the trend of stateless, serverless, and cloud-native for datastores? * What options for S3 compatible blob stores do you have? * Who is using them and what are their tradeoffs or sweet spots?

Break

A High-Speed Data Ingestion Solution in Java Using MQTT, AMQP, and STOMP

Many solutions face challenges when streaming data from thousands of data sources. Smart cities operating IoT networks with sensors such as temperature, pressure, and flow meters are great examples of applications with devices that generate a massive amount of data in the scope of Microservices solutions supporting our cities nowadays.

ActiveMQ is a Java-based open-source message broker that supports REST API and wire-level protocols, such as MQTT, AMQP, and STOMP.

In this talk, we'll create a Java application with examples for each protocol. Then we'll use a public dataset, and ActiveMQ will support Message Oriented Middleware (MOM) to communicate between components and Reactive Streams Ingestion (RSI) to inject the data into a database efficiently, non-blocking way.

Practical introduction to OpenTelemetry tracing

Tracking a request’s flow across different components in distributed systems is essential. With the rise of microservices, their importance has risen to critical levels. Some proprietary tools for tracking have been used already: Jaeger and Zipkin naturally come to mind.

Observability is built on three pillars: logging, metrics, and tracing. OpenTelemetry is a joint effort to bring an open standard to them. Jaeger and Zipkin joined the effort so that they are now OpenTelemetry compatible.

In this talk, I’ll describe the above in more detail and showcase a (simple) use case to demo how you could benefit from OpenTelemetry in your distributed architecture.

Closing ceremony