Why don't you create your next application without a database?

Within every application, data plays a very important role. Currently, we always use a database or a No-SQL solution to store our data externally to the Java process. But this comes with a cost, the impedance mismatch between the object-oriented world of Java and the external data storage. And developers spend a lot of time creating the mapping, writing queries, and optimizing the retrieval from the external system. With MicroStream the data instances within the JVM memory ARE your database. You can query them using the getter methods and the Stream API with extremely high performance and low latency as no mapping or external retrieval is needed. Your Java objects survive the JVM restart because they are serialized to disk for example with a new, from the ground built up very secure serialization solution. In this session, you will learn about the revolutionizing way of data storage with MicroStream. The basic principles, how it works, and demos are part of the agenda of this session.

From objects to functions

Ever since my time at university, I’ve always wanted to write the best code possible. Early on, I realized that OOP is the way. I studied SOLID, GRASP and all the relevant patterns and coding practices. After more than ten years of chasing the perfect OOP code, I realized that my code is finally functional. But how could that be? The answer starts with the basics of object-oriented programming and its goals. I came to the conclusion that OOP solves completely different problems from functional programming. This allows me to think about my code in a radically different way. It leads to modular, maintainable, ready-to-scale code. Forget about polymorphism, inheritance and classes. Open your minds, and let me challenge some basic principles you were convinced are indisputable.

How to build a planet-scale data replication service?

You trust Google Cloud with your critical data, but did you know that Google relies on the same underlying storage infrastructure for its other businesses as well? That’s right, the same storage services that power Google Cloud also underpin Google’s most critical services. Our home-grown copy service is the foundational storage system that takes care of data replication for availability and latency purposes. It supports a diverse range of workloads copying massive amounts of data between all Google data centres around the world. In this talk, we will take a deeper look at the infrastructure behind the planet-scale replication service, discuss the challenges, and the approach taken to ensure that your data is geographically distributed for durability, availability, and latency purposes.

Slack & Micronaut - prefect combo for your side project

Slack is a well-known chat application with 18 million active users and 156 000 organizations using the application every day. It provides an SDK called Bolt and libraries to use this SDK from Spring Boot or Micronaut and other Java frameworks. Writing a Slack application is a perfect choice if you don't want to write any frontend code and you still want to be able to use your application on the go. You even get notifications on your phone and smartwatches as well. Let's look together what are the basic steps to write your first Slack application on Micronaut.

Source code models in the JDK and their use

In this talk, we will show the JDK APIs and tools which provide models of Java source code. We will show how to use them to generate code or perform more strict checks on the source code. We will not only show how to use the standard API for Java source code modelling in the javax.lang.model packages, but also a more detailed API allowing access to the ASTs: Trees API. We will also show how to access the source code models, using either annotation processors or javac compiler Plugins, or by running the javac directly without a command line.

Architectural practices for greater scalability and innovation

When dealing with application scalability, it is common to deal with topics such as microservices, cache, and NoSQL, among other buzzwords in the software engineering area. However, particular needs are often overlooked, such as: ensuring that the organization's point of failure is not IT. But instead the human factor. One of the biggest challenges in software engineering today is ensuring that the technology park grows and innovates while being stable and resilient. Delivering innovation with stability, despite sounding utopian, is possible through well-orchestrated work. This talk will teach practices that lead to a well-documented, multiplier architecture.

Be ‘Mr. Miyagi’ or find one! A talk about the power of mentoring

Mr. Who? Besides one of my childhood heroes, Mr. Miyagi is a fictional karate master from Okinawa, Japan, in the movie serie ‘The Karate Kid’. He was the karate mentor of several people and made them worthy champions. I wanted that too! So began my own karate journey with my own sensei (mentor). Later, I became a lawyer and got a so-called ‘patroon’ (another mentor). Both mentoring relationships have paid off. When I took my first steps in my career switch to the IT world, I discovered that mentorship is not a given. What a pity! Fortunately, I managed to find a mentor again. I experienced it as a difference as night and day. I would like to talk about the mentorship’s ‘what’, ‘who’, ‘how’ and ‘why’. I would also like to explain the importance of mentorship in our field and what it could offer us as a community. In doing so, I would like to share my own experiences and ideas. To add weight to it, I make a link with research. I have looked at whether I can find my own experiences and ideas back in society, science or both. I think that we as a community, but also as an employer and client, should not want anything else and I would like to explain why. After this talk, you'll understand the power of mentoring and how you can make a difference yourself!

Introduction and pitfalls of Java's new concurrency model

Java 19 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.

JetBrains MPS - why modern language workbenches matter

People often develop dialects and domain-specific lingo that let them describe things accurately and communicate effectively. Language workbenches bring the same flexibility into the world of programming languages. The need for high-level computer domain-specific languages is universal and can be identified both in academia and in industry. JetBrains MPS is an open-source language workbench that clients from many industries have chosen to implement their DSLs. We’ll see real-life examples from domains such as medicine, insurance, embedded software development, bioinformatics, enterprise systems and legislation. Why do companies invest in DSLs? What are the key benefits for them? What do typical DSLs look like and how are they implemented? I want to answer these fundamental questions during this practical session.

Keep your dependencies in check

If log4j, Spring4Shell, etc. have taught us anything, it's that we need to keep our dependencies up to date. But updating our applications can take a lot of time. How do we stay on top of that, while also continuing to deliver business value? Luckily, there are plenty of tools that can help us with this, from package managers to bots that can automatically create changes on our repositories. Let's go over some of the different options, so we can make informed choices about what's best for us in a particular situation.

GraalVM & Heap Dumps. Record, replay, analyze

GraalVM EE 21.3 provides revolutionary capabilities when it comes to manipulating heap dump files. Do you want to automatically analyze, process and categorize `.hprof` files collected from crashing kubernetes instances? Do you want to process such files in Java? JavaScript? Python? Your own language? Ever thought about generating `.hprof` files yourself? Analyzing them in your favorite debugger!? All of that and even more magic is possible with the GraalVM ecosystem. Let's explore it in our session!

A testable architecture

An application can only be tested successfully using test automation and executable specifications if the architecture is testable. The tests must be fast, reliable, and offer good diagnosis precision. They must also be easy to write, maintain, and execute. Tests without these properties will be abandoned and the effort creating them will be lost. In this session you will see one battle proven example where I have used executable examples and ended up with a testable architecture as well as living documentation. Takeaways
* With the proper approach, ending up with a testable architecture is doable and fun
* Outside-in development supports test automation
* Re-using executable examples is not too hard when it is implemented properly

It's an HTTP client. It feels like Spring Data. It's a Micronaut declarative HTTP client!

We all value simple solutions to common problems. When the Spring Data was released back in the day, it felt like a huge productivity boost to our daily work. It didn't solve all challenges, of course, but it at least eliminated the need to write an error-prone boilerplate code for the common database operations in the Java code. In this live coding session, I introduce you to the Micronaut framework and one of its handy features - the declarative HTTP client. You will learn how to handle (and customize) HTTP client-server communication, how to prepare for networking problems, and how to test it most effectively.

Locks and versioning in the database transactions

How transaction isolation is achieved in the databases? What trade-offs should we consider? Can we allow clients to read data, while someone is modifying the same data at the same time? Transaction isolation levels were defined based on phenomena which are prohibited for different levels. Locking and versioning are used to isolate concurrent access to the same data by multiple clients. Each of these approaches will trade off with throughput and consistency. Understanding of both approaches will help you to make decisions when it comes to scaling your database. We will play with PostgreSQL to see different phenomena for different transaction isolation level. We will try to understand how PostgreSQL implemented transaction isolation. We will look under the hood how the row version is checked. We will see the implications of versioning and how to deal with them (VACUUM).

How to avoid common mistakes and misconceptions when working with Java on AWS Lambda

AWS Lambda is a serverless, event-driven compute service that lets you run code for virtually any type of application or backend service without provisioning or managing servers. AWS Lambda is chosen for its flexibility, the ease of integration with other AWS Services, and reducing the amount of infrastructure you and your team own. But over time, when the number of clients and requests start to increase, and you start caring about latency, you may discover that there is no free lunch. Clients complain about latency, things you've taken for granted when running your software on EC2 or Fargate no longer apply, and costs start to ramp up. In this talk, I'm going to describe some of the lessons learned from working on multiple services backed by AWS Lambda: what are and how to reduce the cold starts, how the JVM makes them even more problematic, when AWS Lambda is more expensive than the less abstract platform, how to use provisioned concurrency and why one of the biggest problems in Computer Science (caching) is even bigger on Lambdas.

Afraid of Java cold starts in Serverless? Fear not, Java is super fast!

For years, we’ve been told that Java suffers from cold starts in AWS Lambda and Serverless in general. Believe it not. Java is extremely fast to start, the simplest Java program starts in milliseconds. It’s the Java frameworks and libraries that slow things down in general. But not all of them… In this session, I want to show you the truth about Serverless Java and cold starts, what’s slow, what’s fast and why it matters. We’ll go through what a cold start is, how cold starts in AWS Lambda impact your application responsiveness and cloud costs, and what are the options to optimize both. We’ll explore and compare Quarkus and Piranha Cloud, the most modern and fastest Jakarta EE frameworks. We’ll test the limits of what they are capable of, how fast they start and whether we even need to think about any optimizations. Then I’ll explain what optimizations may help if you need to go further, like tuning the JVM, using a custom JVM runtime or building a OS-native binary with GraalVM. However, there are also a few limitations and cost implications of these optimizations, which we'll also explain. I’ll show and tell, with very few slides. You’ll see live for yourselves how Java AWS Lambda functions built with Jakarta EE can start fast and decrease the cold starts to the absolute minimum which you can barely notice.

Integration Testing Strategies & Techniques

Embracing Jakarta EE 10 not only enable you to write better structured applications, it also enables you to write more testable applications. Correctly leveraging CDI enables integration testing where you can simulate a database error and verify that JMS messages are lost due to a RuntimeException. This session will focus on strategies and techniques for testing message handing, transaction management, security, and data model integrity. You will see how you can check message delivery and error handling, session failover, database versioning, and two-phase commits with JMS and databases. All too often assumptions are made that are proven wrong in production. This session will show you how to take your testing to the next level.

Modern Java: This is not your father's Java anymore

In this talk, I will you through all the awesome new stuff you can find in Java..I’ll show you actual usages of these new features so that you can start using them in your project too.Come and see real-world usage for constructs like records, switch functions, sealed classes, and pattern matching to name a few. This is even more important if you consider that the upcoming releases of extremely popular and widely used frameworks such as Spring (v6) and Spring-Boot (v3) will use JDK17 as the minimum baseline for development. Don't get left behind and let me show you how to use all the new language features from JDK11 up to JDK17 in these frameworks. As a bonus, we will also take a look at the hottest features in JDK19, which is released shortly before this conference

Caching beyond simple put and gets

First things first: when there is caching in the talk title, the famous quote from Phil Karlton must follow. So let's get this one out of the way: there are only two hard things in Computer Science - cache invalidation and naming things. Yes, caching is hard. It looks simple at first glance, which leads to a simplistic design and implementation. The application starts slowing down: introduce some caches. Simple library, simply put, a few gets, simple invalidation logic (or maybe not). Fast forward, and we end up with even worse bottlenecks. Instead of fixing an issue, we've just covered it with yet another layer of mud: stalled data (already invalid) in services which cannot be scaled out (different data lands on different nodes) and traded latency and read-access time for risk of actually losing the data (eventual writes). We obviously can do better! In this talk, we will walk through different use-cases (as cache design depends on the use-case) which might require caching. We will look at how caching can be designed effectively. We will start from the business scenario (it's easier to identify with), though an abstraction, to implementation examples on the top of Hazelcast. Everything from zero to a caching hero in a single talk.

IoT in the Trenches, at Scale

If you’ve wired up a Raspberry Pi to some sensors and actuators, you’ve dipped your toes into the internet of things. But there’s a lot more to it that crosses the skill sets of cloud and device engineers. This talk is a tour through issues and approaches, and circles back to Java’s origin (believe it or not) in IoT.

Black Box Optimization for slow, expensive processes

When you have a slow, expensive, optimization process, and the results are not as good as you’d like, how do you choose the parameters for the next run? For example, you run a machine learning training session, and the metric you want to maximize, say balanced accuracy, is not as high as you’d like; or you run an A/B test, and the time-on-site and revenue are not too good on either test A or test B. A new interaction pattern, “Black Box”, as implemented by the new Google Vizier project, addresses these difficult optimizations. You are responsible for the ML training session, the A/B testing, or other optimization process, and you only tell the optimizer the parameters you used, and the metric that resulted. It suggests the parameters to use for the next run, but it only suggests, and it’s up to you whether to use these parameters. The optimizer knows nothing about each trial – not even if it is ML – only the parameters and metrics. As a result, this approach is highly scalable, robust, and applicable to a wide range of applications. The focus of the talk is the Black Box architecture, and I will illustrate this with Google Vizier. Its REST API for Black Box optimization is simple, yet also provides richer optional functionality like choice of hyperoptimization algorithm, sensitivity to noise, and advice on early stopping.

Real-time Fraud Detection: Challenges and Solutions

Fraud can be considerably reduced via speed, scalability, and stability. Investigating fraudulent activities, using fraud detection machine learning is crucial where decisions need to be made in microseconds, not seconds or even milliseconds. This becomes more challenging when things get demanding and scaling real-time fraud detection becomes a bottleneck. The talk will address these issues and provide solutions using the Hazelcast Open Source platform.

Distributed Object Graphs with MicroStream

Hibernate and relational databases have been the standard persistence for traditional monolithic applications for decades. However, using traditional persistence concepts for cloud-native microservices is mostly oversized, complex, and expensive. With MicroStream there is a cloud-native alternative. It is a micro persistent layer built for microservices that delivers lots of benefits. It allows persisting any Java object graph of any size and complexity in plain files, cloud blob stores, or any cloud DB. It enables ultra-fast in-memory data processing with microsecond query and response time, and now clustering and elastic auto-scaling containerized microservices. Implementing is even way faster and simpler than any database, to reduce complexity, effort, time-to-market, and cloud costs. MicroStream is open source and integrated with Micronaut and Helidon.

GraalVM: Java ♥ Python ♥ Micronaut

GraalVM is a distribution of HotSpot/OpenJDK that, aside from the well know native image tool, adds the possibility to seamlessly embed Python into JVM applications with GraalPython. This opens the world of dynamic scripting and data science libraries to your Java/Scala/Kotlin and other JVM projects! This talk will introduce GraalPython, and will demonstrate its usage in Java applications by extending the standard Micronaut chat application example with Python scripting capabilities.

Modern Java Microservices in the Cloud!

It's 2022, long gone are the days of ceremony and Java development should be productivity, simplicity. Let's look at how we make it happen, in context of startup going FAST. I will describe the architectural approach we use stack we use, and what, sometimes unorthodox, technology and design choices we have made, and their consequences. Expect: code samples, why does our stack look the way it looks AND… what have we learnt in the process.

Micronaut Turbo - The return of the Monolith

In this session, Sergio del Amo introduces Turbo integration with the Micronaut® Framework. Turbo allows you to get the speed of a single-page web application without writing any JavaScript. Turbo bundles several techniques for creating fast, modern, progressively enhanced web applications without using much JavaScript. It offers a simpler alternative to the prevailing client-side frameworks, which put all the logic in the front-end and confine the server-side of your app to being little more than a JSON API. Topics include: Integrating Turbo in a Micronaut Application. Use Micronaut Views Templates with Turbo Frames and Turbo Streams. Respond Turbo Frames with the @TurboFrameView annotation. Respond to form submissions using just HTML and a set of CRUD-like actions with Turbo Streams. Deliver page changes with Turbo Streams over WebSockets. Respond Turbo Streams with the @TurboView annotation. Micronaut Turbo brings back the joy of building web applications with JVM languages. Target Attendees Everyone is welcome. However, we recommend attendees have at least a working familiarity with web development, HTTP, Java, and JVM development frameworks. Experience with Micronaut is a plus, but not required.

A parallel programming language extension for Java

The notion of 'thread' is a hardware-level concept that made its way into high-level languages. This impedance mismatch is one of the reasons why parallel programming is so complex and so painful, but it doesn't need to be that way. I will present a language-integrated parallel programming model based on a few simple additions to the Java language using compositional operators. This model is based on strong theoretical foundations, which makes it amenable to correctness proofs. I will claim, based on a number of examples, that it makes parallel programming simpler, more intuitive, more general and more efficient.

Pyrsia - Trusted Decentralized Package Network

Not knowing where all your software comes from means hard-to-spot risks to the integrity of your services. Without constant identity checks and safety protocols for keys and secrets, open source dependencies can open the door to breaches, exploits and supply chain attacks. This session discusses the open source project, Pyrsia, which addresses the mentioned security challenges by using Rust, the concept of distributed networks (p2p), blockchain, and seamlessly integrating with the popular packages and binaries that developers are already using.

Meet James, the most famous Java Developer!

Imagine James. Imagine the most famous Java Developer being around. What kind of question would you ask him? What were his programming beginnings? What led James to Java? What does he think about contemporary Java? Is it still the same language as in the nineties? What development tools he's using? Is JDK What kind of technologies interests him most? Have he ever been in Prague before?

CompletableFuture and its Quirks

CompletableFuture revolutionised asynchronous processing in Java. Unfortunately, it’s full of quirks, traps, and surprises… during this live coding session, we’ll have a look at things like: thread pools backing task execution, exception propagation, cancellations, and unintuitive methods from the public API.

The `-ilities` of Software Engineering - How Qualities that go Beyond Functional Requirements Drive Innovations in Managed Runtimes

TBA

Helidon Nima - Loom based microservices framework

For quite a long time we were forced to make a choice - performance vs. simplicity. Either use a complicated and performant reactive code, or use simple, yet limited blocking approach.Thanks to project Loom in JDK, the paradigm can shift once more even for applications that require high concurrency. I will introduce Helidon Nima - new microservices framework which is built on top of a server designed for Loom with fully synchronous routing that can block as needed, yet still provide high performance under heavy concurrent load. I'll also talk about challenges, benefits and impact on application development in such an environment. - Is it the end of reactive programming?

The Future of Hazelcast

Hazelcast is going through a cloud-native revolution and is no longer just a cache. It's not a stream processing engine, either. Let me give you a tour of what we're working on and what can you expect in the near and not-so-near future.

Developer experience platforms

Moving user experience and customer experience into the spotlight has made companies more successful. We're now seeing a strong interest in improving developer experience, too. One reason is efficiency. We want deliver more with the same development team. The key reason, though, is that a good developer experience leads to more responsive IT, which, in turn, leads to a more responsive and more successful business. As a consultant Erik has seen how several organisations have built internal platforms to improve developer experience. In this talk he will share his observations on when it makes sense to build such a platform and on how to build and evolve it. This is complemented by a description of underlying technolgies, princicples, and practices.

Blockchain technology can be a powerful tool if you know how to use it

Cryptocurrencies took over the world by storm. During the last year, the demand for blockchain developers grew by over 500%. Have you ever wondered why this technology is so popular? Is this just a trend or there is something more to it? Do you even need any special knowledge for it? We will find an answer to all of these questions and even more. During this presentation, we will take a deeper look at Blockchain technology and Satoshi Nakamoto's whitepaper. Learn about the basics of concepts like Proof of Work and Proof of Stake. Take a look at how and why we can utilize this technology in our authorization and authentication procedures and discuss the possibilities of integrating blockchains with our existing Java BE applications.

Real cloud-native with serverless Java

Serverless cloud computing provides you with an infrastructure out of the box to run your containerized microservices highly efficiently. Java integrates seamlessly with serverless infrastructure and leads to strong benefits: highest efficiency, endless scalability, high availability, the lowest possible effort for development, production usage, administration, and maintenance.

Sailing Modern Java

Another (half a) year has passed, another major Java™ version has been released. Java was supposed 'to be slow'. However, Java turns out to evolve so fast, that next releases aren't just version bumps, but might significantly change the rules of the game. That's a good reason to check out what's new in Java. We're going to cover some features of recent Java versions:

Rethinking Unit Testing: Automating the Generation of Java Unit Tests

In an ideal world, any code we write would be tested in real time, letting us catch bugs on the fly to write 100% correct code. Automated test cases can help us move closer to this ideal, keeping code behavior stable and implementations regression-free. Test-driven development is a step ahead, allowing us to write better code and extend test suites one behavior at a time. However, all those test cases still need to be written manually, a painful time-consuming process that leaves plenty of room for error. Manually written tests often tend to be flawed, focusing on the happy path and overlooking corner cases and bugs. In this talk, Markus Zimmermann argues for a new way to dramatically improve unit testing. By generating unit tests based on the current implementation automatically rather than manually, we can improve productivity and catch bugs on the fly, while code is being written.

Micronaut Libraries for a Real Life

Agorapulse is an early adopter of Micronaut, and since the first Micronaut function deployed, we also started to open source our helper libraries. These are the ones you most likely would like to use in your projects. Gru for Micronaut helps you test your HTTP endpoints. Micronaut Console is a keyhole surgery tool that allows you to execute arbitrary code inside your application at runtime. Micronaut Worker can be considered a boosted version of the native Micronaut scheduler. It supports distributed execution with producer and consumer jobs. Micronaut Permissions framework allows you to define fine-grained business-oriented security rules inside your application.

Exploring Jakarta EE integration testing

Testing applications is challenging because repeatable tests require additional systems, such as databases, in a specific state. Despite the fact that Jakarta EE doesn't have any testing specifications, you can perform integration testing for your application using several libraries. We have a look at the libraries with an example and the problems each of them has. In addition, we will examine the Testcontainers framework, which allows developers to test real-world applications by deploying them in containers using the production runtime and its dependent systems. An application can be tested and remotely debugged using one of the libraries we explore further.

Admire Kotlin, adhere to Java19!

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

Closing ceremony

TBA

To Be Announced

Lightning talks

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 7

Beef bourgignon + rice + salad (gluten free)

Lunch - room 5

Grilled chicken in red pesto sauce + pearl barley with vegies + salad

Lunch - room 3

Caponata + rice (vegan)

Lunch - room 7

Beef strogonof + buckwheat with vegies+ salad (gluten free)

Lunch - room 5

Chicken fillet in a cream parsley sauce + wild rice

Lunch - room 3

Galician dumplings + salad (vege)

Lunch - room 7

L3_1

Lunch - room 5

L3_2

Lunch - room 3

L3_3