Say Goodbye to Microservices, Say Hello to Self-Contained Systems en

Microservices are a popular approach to building modern software, offering scalability and flexibility. But for many teams, they come with challenges like increased complexity, difficult debugging, and managing too many small services.

In this talk, we'll introduce an alternative: Self-Contained Systems (SCS). Unlike microservices, SCS allows each part of your application to operate independently with its UI, logic, and database, simplifying both development and deployment.

You'll learn why SCS can be a better fit for many projects, how it reduces the complexity of distributed systems, and when it makes sense to use this approach over microservices. We'll also dive into my current customer project which shows you how to build self-contained systems using Java and Vaadin.

If you're ready to rethink your architecture and say goodbye to microservice headaches, this talk will show you the way!

Microservices promise simplicity and scalability, but for many teams, they’ve become a source of complexity and operational headaches. In my talk, I'll introduce Self-Contained Systems (SCS) as a simpler alternative. SCS allows each part of an application to function independently, reducing the need for complex inter-service communication. If you're tired of the microservices maze, this is the path forward.

Full-stack development done right and completely with Java! en

More efficient solutions are often overlooked because of the dominance of Single Page Application (SPA) frameworks. However, creating data-centric web applications can be easy with Java and the right tools.

In this deep dive, I will show you how to develop a web application in Java using Vaadin, jOOQ, Spring Boot, and PostgreSQL.

We will start by defining the database model and setting up jOOQ for data access. Next, we will build the user interface with Vaadin and see how it integrates with Spring Security.
Data access can often be a performance bottleneck, so we will explore lazy-loaded grids and binders, which make displaying and editing data straightforward.

Testing is crucial, and we will cover browser-less testing with Karibu and end-to-end testing with Playwright. Additionally, you will learn how to use TestContainers, enabling you to use the same database for development, testing, and production.

CQRS mit modernem Java de en

Command Query Responsibility Segregation (CQRS) ist ein bewährtes Entwurfsmuster, das die klare Trennung von Datenveränderungen (Commands) und Datenabfragen (Queries) ermöglicht. Diese Trennung erlaubt die eigenständige Skalierung und Optimierung dieser Verantwortlichkeiten. Ebenfalls wird der Anwendungscode verständlicher strukturiert was die Wartbarkeit verbessert.

In diesem Vortrag wird das Verständnis der praktischen Umsetzung der CQRS-Prinzipien vertieft und mit modernen Java Sprachmitteln wie Records, Switch-Expressions und Pattern Matching umgesetzt.

Anhand einer Beispielanwendung wird demonstriert, wie die theoretischen Grundlagen von CQRS in der Praxis angewendet werden können und welche Auswirkungen dies auf das Design von Anwendungen hat und gleichzeitig die Effizienz des Datenzugriffs steigert.

Viele Anwendungs-APIs folgen den REST-Prinzipien und senden Ressourcen als JSON hin und her. Aber was genau bedeutet die API? Hier kann CQRS zur besseren Verständlichkeit beitragen.

CQRS meets modern Java de en

Command Query Responsibility Segregation (CQRS) is a proven design pattern that enables the clear separation of data changes (commands) and data queries (queries). This separation allows these responsibilities to be scaled and optimized independently. The application code is also structured more understandably, which improves maintainability.

This talk will deepen our understanding of the practical implementation of the CQRS principles using modern Java language features such as records, sealed classes, switch expressions, and pattern matching. An example application will demonstrate how the theoretical foundations of CQRS can be applied in practice and how this affects application design while increasing data access efficiency.

Many application APIs follow the REST principles and send resources back and forth as JSON. But what exactly is the API's meaning? That's where CQRS can help improve understandability.

Do you really need JavaScript? en de

Single Page Applications (SPAs) have emerged as the de facto standard for modern web application development, with Angular, React, and Vue.js leading the pack. However, for Java developers, diving into the world of SPAs often means learning new programming languages and unfamiliar build environments, presenting a steep learning curve.

This presentation introduces an alternative path for Java developers: Vaadin. This well-established web framework enables the development of web applications entirely in Java while also accommodating the classic SPA approach. We will start with the architecture of Vaadin, shifting away from its previous reliance on GWT in favor of WebComponents, and then highlight the benefits and advantages of this framework.

The second part of the talk will feature practical examples from ongoing projects, showcasing how Vaadin enhances efficiency by using the simplicity and familiarity of Java, even in mobile-first application development.

This presentation provides valuable insights for Java developers seeking an alternative to traditional SPA frameworks. It introduces Vaadin and demonstrates its potential within the Java ecosystem. Whether you're a seasoned Java developer or new to the language, this talk aims to inspire and inform your journey toward a more Java-centric approach to web development.

Muss es wirklich JavaScript sein? en de

Single Page Applications (SPAs) haben sich zum De-facto-Standard für die moderne Webanwendungsentwicklung entwickelt, wobei Angular, React und Vue.js die Spitzenreiter sind. Für Java-Entwickler bedeutet das Eintauchen in die Welt der SPAs jedoch häufig das Erlernen neuer Programmiersprachen und unbekannter Build-Umgebungen, was eine steile Lernkurve mit sich bringt.

Diese Präsentation stellt einen alternativen Weg für Java-Entwickler vor: Vaadin. Dieses etablierte Webframework ermöglicht die Entwicklung von Webanwendungen vollständig in Java und berücksichtigt gleichzeitig den klassischen SPA-Ansatz. Wir werden uns mit der sich entwickelnden Architektur von Vaadin befassen, uns von der bisherigen Abhängigkeit von GWT zu Gunsten von WebComponents verlagern und die Vorteile und Vorzüge dieses Frameworks hervorheben.

Im zweiten Teil des Vortrags werden praktische Beispiele aus laufenden Projekten vorgestellt und gezeigt, wie Vaadin Entwickler in die Lage versetzt, die Effizienz zu steigern, indem es die Einfachheit und Vertrautheit von Java nutzt, selbst bei der Entwicklung von Mobile-First-Anwendungen.

Diese Präsentation bietet wertvolle Einblicke für Java-Entwickler, die eine Alternative zu herkömmlichen SPA-Frameworks suchen, bietet einen Einblick in die Welt von Vaadin und demonstriert dessen Potenzial innerhalb des Java-Ökosystems. Ganz gleich, ob Sie ein erfahrener Java-Entwickler oder ein Neuling in der Sprache sind, dieser Vortrag soll Sie auf Ihrem Weg zu einem stärker Java-zentrierten Ansatz für die Webentwicklung inspirieren und informieren.

Workshop: Efficient Data Access with jOOQ en de

SQL was never meant to be abstracted. To be confined in the narrow boundaries of heavy mappers, hiding the beauty and simplicity of relational data. SQL was never meant to be object-oriented. SQL was never meant to be anything other than… SQL! - Lukas Eder, the creator of jOOQ.

What’s the best way to use SQL with Java? Often JPA/Hibernate is used without rethinking the choice. But there are other frameworks like jOOQ that, in many situations, maybe a better fit.

This workshop will teach you how to use jOOQ with Spring Boot, Flyway, and Testcontainers to access SQL databases efficiently.

AGENDA
After a quick start, the workshop will do a deep-dive into the features of jOOQ and the integration with Spring Boot and how to use it in combination with JPA

Setting up jOOQ, Spring Boot, Flyway, and Testcontainers
How to use the jOOQ DSL for SQL building
Generating the metamodel for writing type-safe queries
Execute queries and process results, including nested Java Records and multisets
Call stored procedures and use functions
Use transactions
How does the jOOQ Spring Boot auto-configuration work
Use the best of both worlds. How to integrate jOOQ with JPA

Full-Stack development is dead, long live Full-Stack development! en de

The gap between frontend and backend in web development has widened in recent years. In frontend programming, frameworks such as Angular, React, or Vue.js are predominant, forcing developers to use a different programming language and a different ecosystem.

This has made it more difficult for Java developers to find their way around, and in many projects, frontend and backend developers are separated.

However, it can be beneficial in many ways if a developer can develop both the frontend and backend. But as a Java developer, do I have to get familiar with a whole new ecosystem?
No, there are alternatives!

This talk shows how to develop web applications quickly as a Java full-stack developer. We will compare three options that suit the Java developer: Thymeleaf with htmx, Vaadin, and Hilla. Based on an example, we look at the advantages and disadvantages to determine which framework is the best choice in which scenario.

Full-Stack Entwicklung - darf man das noch? en de

Der Graben zwischen Frontend und Backend in der Webentwicklung hat sich in den letzten Jahren vergrößert. In der Frontend-Programmierung dominieren Frameworks wie Angular, React oder Vue.js, die Entwickler dazu zwingen, eine andere Programmiersprache und ein anderes Ökosystem zu verwenden.

Dadurch ist es für Java-Entwickler schwieriger geworden, sich zurechtzufinden, und in vielen Projekten werden Frontend- und Backend-Entwickler getrennt.
Es kann jedoch in vielerlei Hinsicht von Vorteil sein, wenn ein Entwickler sowohl das Frontend als auch das Backend entwickeln kann. Aber muss ich mich als Java-Entwickler in ein ganz neues Ökosystem einarbeiten?
Nein, es gibt Alternativen!

Dieser Vortrag zeigt, wie man als Java-Full-Stack-Entwickler schnell Webanwendungen entwickelt. Wir werden drei Varianten vergleichen, die für den Java-Entwickler geeignet sind: Thymeleaf mit htmx, Vaadin und Hilla. Anhand eines Beispiels betrachten wir die Vor- und Nachteile, um festzustellen, welches Framework in welchem Szenario die beste Wahl ist.

Going Full-stack with Hilla en de

Full-stack development is often a good choice when developing business applications. But the integration of the frontend and the backend is not trivial.

Hilla to the rescue!
Hilla integrates a Spring Boot Java backend with a reactive TypeScript frontend. You build UIs using Lit framework or React and web components without caring about a REST API. Hilla generates the REST-API and the client code for you.
The backend is secure by default and fully stateless.

Hilla was made by the creators of the famous Java web framework Vaadin. This talk introduces the architecture and concepts of Hilla and Lit. A hands-on demo shows how easy it is to do full-stack development using Hilla and Spring Boot.

Efficient Full-Stack Development with Java en de

Single Page Applications (SPA) have become the quasi-standard in the development of web applications today. Angular, React, and Vue.js are the most well-known representatives of this category of web frameworks.

For Java developers, however, this means learning a new programming language and finding a completely foreign build environment with its ecosystem, which can often be more difficult.

Are there alternatives?
Vaadin is an established web framework that allows web applications to be developed entirely in Java but recently also supported a classic SPA approach.
First, the new architecture of Vaadin, which is no longer based on GWT but WebComponents, is explained.

The second part explains Hilla (former Vaadin Fusion), which offers the possibility to develop SPAs with TypeScript and WebComponents in the frontend and Java in the backend.

You may not need JavaScript en de

Single page applications (SPA) have become the for web application development. Angular, React, Vue.js and Ember.js are the best known representatives from this category of web frameworks. But does this client architecture fit every application? Or are there alternatives that may fit better and are less complex to develop?

In the first part of the talk, the differences between SPAs and classic, server-side approaches are explained and the advantages and disadvantages are discussed.

The second part reports on a current customer project in which the front end of a large ERP system had to be replaced by a modern web front end. The chosen framework is Vaadin Flow, a server-side web framework that makes development of web applications entirely in Java possible.

First, the new architecture of Vaadin Flow, which is no longer based on GWT but on web components, is explained. Then it will be shown how configurable, form-based and data-centric web applications can be implemented very efficiently by using jOOQ as a database access layer.

The Real Value of Microservices en de

For older software developers new trends are often nothing but "old wine in new bottles." That's exactly what I thought when I heard about microservices for the first time.
Through my work as a software renovator, though, I realized that many aspects of microservice architectures have a huge impact on value retention and can greatly simplify future migrations.

The first part of the talk will explain how microservice architectures are based on some very old principles, and will discuss the advantages they bring for the life cycle of an application. In the second part, I will discuss my experience in a recent customer project and how it demonstrates how to move from a monolithic legacy application to a modern, sustainable microservice architecture.

Die Rückkehr des Full-Stack-Entwicklers de en

Full-Stack-Entwicklung, bei der ein Entwickler sowohl am Front-End als auch am Back-End einer Anwendung arbeitet, erfreut sich wieder zunehmender Beliebtheit. In diesem Vortrag erkläre ich, warum Full-Stack-Entwicklung heute wichtig ist und welche Vorteile sie bietet.

Ich zeige auf, wie Java-Entwickler Frameworks wie Vaadin, Spring Boot mit JTE, Quarkus mit Qute und HTMX sowie JSF verwenden können, um schnell und einfach vollständige Webanwendungen zu erstellen. Egal, ob sie ein erfahrener Java-Entwickler sind oder gerade erst mit der Full-Stack-Entwicklung beginnen, in diesem Vortrage erhalten sie praktische Tipps und Beispiele, die Ihnen helfen, produktiver zu sein.

Do we still need Spring Data JPA? en

In this talk, we'll compare the recent query and finder methods added to Hibernate 6.3 with the familiar Spring Data JPA, focusing on how they can used to handle data access in Java. Using code examples, we'll uncover what each framework offers and where its strengths lie.

The big question we'll tackle: Does the functionality of Hibernate 6.3 make Spring Data JPA unnecessary? We'll break down scenarios where Spring Data JPA shines and contrast them with the fresh features of Hibernate 6.3.

Who needs JavaScript when there is Java? en

The gap between front-end and back-end in web development has widened in recent years. In front-end programming, frameworks such as Angular, React, or Vue.js are predominant, forcing developers to use a different programming language and ecosystem. This has made it more difficult for Java developers to keep up with front-end development, and in many projects, front-end and back-end developers are separated.

However, it can be beneficial if a developer can develop both the front-end and back-end. But as a Java developer, do I have to get familiar with a whole new ecosystem? 
No, there are alternatives!

This deep dive shows how to develop web applications efficiently as a Java full-stack developer. We will compare three options that suit the Java developer: Vaadin, Quarkus Qute with HTMX, and Jakarta Faces (JSF). We will examine the advantages and disadvantages based on an example to determine which framework is the best choice in each scenario.

Return of the Full-Stack Developer de en

Full-stack development, where one developer works on both the front-end and back-end of an application, is becoming popular again. In this talk, I will explain why full-stack development is important today and the benefits it brings to modern projects.

I will focus on how Java developers can use frameworks like Vaadin, Spring Boot with JTE, Quarkus with Qute and HTMX, and JSF to build complete web applications quickly and easily. Whether you are an experienced Java developer or just starting with full-stack development, this session will give you practical tips and examples to help you be more productive.

Full-stack development is making a strong comeback, and Java developers have powerful tools to take advantage of it. In this talk, I’ll show how Java frameworks allow developers to efficiently build modern, complete web applications without needing to juggle multiple languages and tools.

Der wahre Wert von Microservices en de

Für erfahrene Softwareentwickler sind neue Hypes häufig nichts anderes als «alter Wein in neuen Schläuchen». Genau so ist es mir mit dem Thema Microservices ergangen.

Durch meine Tätigkeit als Softwaremodernisierer ist mir jedoch klar geworden, dass gewisse Ideen aus dem Umfeld der Microservicearchitekturen die Werterhaltung der Applikationen fördern und spätere Migrationen stark vereinfachen.

Der Vortrag zeigt auf, welche, zum Teil sehr alten, Prinzipien in Microservicearchitekturen enthalten sind und welche Vorteile diese für den Lebenszyklus einer Applikation bringen.

Im zweiten Teil werde ich anhand eines aktuellen Kundenprojekts zeigen welches Vorgehen nötig ist um von einer monolithischen Legacyapplikation zu einer modernen, nachhaltigen Microservicearchitektur zu gelangen.

Es muss nicht immer Angular sein en de

Single Page Applikationen (SPA) sind heute bei der Entwicklung von Webanwendungen zum Quasi-Standard geworden. Angular, React, Vue.js und Ember.js sind die bekanntesten Vertreter aus dieser Kategorie von Webframeworks. Aber passt diese Client-Architektur zu jedem Anwendungsfall? Oder gibt es Alternativen die eventuell besser passen und weniger aufwändig in der Entwicklung sind?

Im ersten Teil des Vortrags werden die Unterschiede zwischen SPAs und klassischen, serverseitigen Ansätzen erläutert und auf die jeweiligen Vor- und Nachteile eingegangen.

Der zweite Teil berichtet über ein aktuelles Kundenprojekt, bei welchem das Frontend eines grossen ERP Systems durch ein modernes Webfrontend ersetzt werden musste. Die Frameworkwahl fiel dabei auf Vaadin Flow, ein serverseitiges Webframework das verspricht, Webanwendungen vollständig in Java entwickeln zu können.

Zuerst wird die neue Architektur von Vaadin Flow, welche mittlerweile nicht mehr auf GWT sondern auf Webcomponents basiert, erklärt. Dann wird aufgezeigt, wie durch die Zuhilfenahme von jOOQ als Datenbankzugriffsschicht konfigurierbare, formularbasierte und datenlastige Webanwendungen sehr effizient umgesetzt werden können.

Effiziente Full-Stack-Entwicklung für Java Entwickler en de

Single Page Applikationen (SPA) sind heute bei der Entwicklung von Webanwendungen zum Quasi-Standard geworden. Angular, React und Vue.js sind die bekanntesten Vertreter aus dieser Kategorie von Web-Frameworks.

Für Java Entwickler bedeutet das aber, erstens eine neue Programmiersprache zu lernen und zweitens, was oft schwieriger sein kann, eine komplett fremde Build-Umgebung mit einem eigenen Ökosystem vorzufinden.

Gibt es Alternativen?
Vaadin ist ein etabliertes Web-Framework, das es erlaubt Webanwendungen komplett in Java zu entwickeln, neuerdings aber auch einen klassischen SPA-Ansatz unterstützt.

Zuerst wird die neue Architektur von Vaadin, welche mittlerweile nicht mehr auf GWT sondern auf WebComponents basiert, erklärt.

Anhand eines Kundenprojekts wird aufgezeigt, wie damit formularbasierte und datenlastige Webanwendungen sehr effizient umgesetzt werden können.

Im zweiten Teil wird auf Hilla (ex Vaadin Fusion) eingegangen, welches die Möglichkeit bietet SPAs mit TypeScript und WebComponents im Frontend und Java im Backend zu entwickeln.

Do you really need Hibernate? en de

Projects often use Java Persistence API (JPA) by default and, thus, mostly Hibernate. But do all applications need a comprehensive object/relational mapping (ORM) with all conceivable functions?

This talk examines the architecture of database-centric applications and discusses whether you always need an object graph for persistence.

Using an example application, it is shown how pure SQL, with the help of jOOQ and (nested) Java Records simplifies data access and how common ORM problems, such as the n+1 select problem, can be avoided.
Finally, the possibility of combining jOOQ and JPA/Hibernate and thus using the best of both worlds is discussed.

Muss es wirklich Hibernate sein? en de

Projekte verwenden oft standardmässig Java Persistence API (JPA) und damit meistens Hibernate.
Aber braucht es in allen Applikationen wirklich ein vollumfängliches Objekt/Relationales-Mapping (ORM) mit allen erdenklichen Funktionen?

Dieser Talk beleuchtet die Architektur von datenbank-zentrierten Applikationen und diskutiert die Frage ob man immer einen Objektgraphen für die Persistenz braucht.

Anhand einer Beispielapplikation wird aufgezeigt wie mit reinem SQL mit Hilfe von jOOQ und (verschachtelten) Java Records der Datenzugriff vereinfacht und häufige Probleme von ORM wie z.B. das n+1-Select-Problem vermieden werden kann.
Abschließend wird auf die Möglichkeit eingegangen jOOQ und JPA/Hibernate zu kombinieren und damit das Beste aus beiden Welten zu verwenden.

Full-Stack-Entwicklung mit Hilla en de

Full-Stack-Entwicklung ist oft eine gute Wahl bei der Entwicklung von Geschäftsanwendungen. Aber die Integration von Frontend und Backend ist nicht trivial.

Dieses Problem löst Hilla.
Hilla integriert ein Spring Boot Java-Backend mit einem reaktiven TypeScript-Frontend. Benutzeroberflächen werden mit dem Lit-Framework oder React und Webkomponenten erstellt und sie müssen sich nicht um die REST-API kümmern. Hilla generiert die REST-API und den Client-Code. Das Backend ist standardmäßig sicher und vollständig zustandslos.

Hilla wurde von den Machern des bekannten Java-Webframeworks Vaadin entwickelt. Dieser Vortrag stellt die Architektur und Konzepte von Hilla und Lit vor. Die Demo zeigt, wie einfach es ist, Full-Stack-Entwicklung mit Hilla und Spring Boot zu erstellen.

Workshop: Effizienter Datenbankzugriff mit jOOQ en de

SQL war nie dazu gedacht, abstrahiert zu werden. In den engen Grenzen schwergewichtiger Mapper gefangen zu sein und die Schönheit und Einfachheit relationaler Datenbanken zu verbergen. SQL war nie dazu gedacht, objektorientiert zu sein. SQL war nie dazu gedacht, etwas anderes zu sein als … SQL! - Lukas Eder, der Erfinder von jOOQ.

Was ist der beste Weg, um SQL mit Java zu verwenden? Oft wird JPA/Hibernate verwendet, ohne die Wahl zu überdenken. Aber es gibt andere Frameworks wie jOOQ, die in vielen Situationen besser passen.

In diesem Workshop lernen Sie, wie Sie jOOQ mit Spring Boot, Flyway und Testcontainers verwenden, um effizient auf SQL-Datenbanken zuzugreifen.

AGENDA
Nach einem Quick-Start wird der Workshop einen Einblick in die Funktionen von jOOQ und die Integration mit Spring Boot geben und wie man es in Kombination mit JPA verwendet

1. Einrichten von jOOQ, Spring Boot, Flyway und Testcontainern
2. jOOQ DSL für die die Erstellung von SQL Abfragen verwenden
3. Generieren des Metamodells zum Schreiben typsicherer Abfragen
4. Abfragen ausführen und verarbeiten der Ergebnisse, einschliesslich verschachtelter Java Records und Multisets
5. Stored Procedures und Funktionen aufrufen
6. Transaktionen und jOOQ
7. Wie funktioniert die automatische Konfiguration von jOOQ in Spring Boot?
8. Nutze das Beste aus beiden Welten. jOOQ mit JPA integrieren.

Workshop: Java Full-Stack Entwicklung mit Vaadin de en

Einleitung

Single Page Applikationen (SPA) sind heute bei der Entwicklung von Webanwendungen zum Quasi-Standard geworden. Angular, React oder Vue sind die bekanntesten Vertreter aus dieser Kategorie von Webframeworks. Aber passt diese Client-Architektur zu jedem Anwendungsfall? Oder gibt es Alternativen die eventuell besser passen und weniger aufwändig in der Entwicklung sind?
Vaadin ist ein bewährtes Webapplikationsframework mit einer langen Geschichte und wurde vor vier Jahren runderneuert.
Die neuste Version basiert auf einer modernen Architektur mit Webcomponents und erlaubt es Webapplikationen vollständig in Java zu entwickeln.

Programm

Themen
- Architektur und Konzepte von Vaadin
- Spring Boot Integration
- Routing
- Application Lifecycle
- Formular und Data Binding
- Grids und Data Provider
- Theming
- I18N
- Push

Anhand einer Beispielapplikation werden wir die Theorie in die Praxis umsetzen.

Kursziel

Die Teilnehmer verstehen die Konzepte von Vaadin und können mit dem Vaadin Framework effektive sowie attraktive Full-Stack Java Anwendungen entwickeln.
Adressaten
Der Workshop richtet sich an alle Java Entwickler mit Interesse an modernen Webapplikationen

Voraussetzungen

Java Kenntnisse

Infrastruktur

- Aktuelle IDE
- Aktuelles Java Version
- Notebook mit Internetzugang

Workshop: Java Full-Stack Development with Vaadin de en

Introduction

Single Page Applications (SPA) have become a quasi-standard in the development of web applications. Angular, React, and Vue are the best-known representatives from this category of web frameworks. But does this client architecture fit every use case? Or are there alternatives that might be a better fit and less time-consuming to develop?
Vaadin is a proven web application framework with a long history and was overhauled four years ago.
The latest version is based on a modern architecture with web components. It allows web applications to be developed entirely in Java.

Program

Topics
- Architecture and concepts from Vaadin
- Spring Boot integration
- Routing
- Application Lifecycle
- Form and data binding
- Grids and data providers
-Theming
- I18N
-Push

We will put the theory into practice using an example application.

Workshop Goals

Participants understand the concepts of Vaadin and can develop effective and attractive full-stack Java applications using the Vaadin Framework.

Target audience

The workshop is aimed at all Java developers interested in modern web applications.

Requirements

Java knowledge

Infrastructure

- Up-to-date IDE
- Latest Java version
- Notebook with internet access