I’m a regular speaker at international conferences and Java User Groups. Here are some of my current talks:
- Cause of Death: Hibernate
- 3 Patterns for Scalable Microservices
- Hibernate Tips ‘n’ Tricks – 15 Tips to solve common problems
- Hibernate in complex projects – Can we be a little faster?
Cause of Death: Hibernate
#Hibernate #BestPractices #Performance
For years Hibernate has been optimized to store data and load entire object graphs from the database. So you should assume that most persistence problems could be avoided by using Hibernate alone.
But it’s surprisingly easy to harm your project with … or should I better say “thanks to Hibernate” …
From practical experience I show in this talk how to:
- delete most of your data with just one annotation,
- implement the persistence logic in such a way that nobody will understand it,
- reliably prevent the use of the entities in client applications and
- bring the database to its knees with thousands of queries.
If you’ve ever wanted to cause a project to fail with the help of Java’s most popular OR mapper, you shouldn’t miss this talk!
3 Patterns for Scalable Microservices
When you’re implementing scalable and independent microservices, exchanging data between them quickly becomes a challenge. You need to ensure consistency but distributed transactions create tight coupling and are no longer an option. The same is true for synchronous service calls.
You need new approaches that allow you to exchange data asynchronously and ensure its consistency.
Most architectures achieve that using 3 patterns: The Outbox Pattern, the View Database Pattern, and the SAGA Pattern.
With the help of the outbox pattern, events are stored in Kafka and data in the service’s own database. Based on this, other services can either store the data in their own view database or participate in a complex SAGA to secure a distributed write operation.
In this talk, I will show exactly how all this works and what to look out for.
Hibernate Tips ‘n’ Tricks – 15 Tips to solve common problems
You probably know this situation: Your customer asks for “just a tiny, little change”. After a few hours … or days … you recognize that you can’t implement it that easily.
You probably start thinking: “I can’t be the first who tries to implement this!”
And you’re probably right.
Hibernate provides a lot of lesser-known features that help you to implement common requirements quickly. The problem is that most developers don’t know about them. They spend days creating their own solution when it just takes an annotation or a few lines of code to:
- implement multi-tenancy
- support a database-specific data type
- map an SQL-snippet instead of a database column to an entity attribute
- retrieve the elements of a mapped association in a defined order
- generate UUIDs as primary keys
- write an audit log documenting all changes performed on an entity
- and more …
Hibernate in complex projects – Can we be a little faster?
#Hibernate #BestPractices #Performance
Hibernate is the de-facto standard for persisting data in a relational database. It provides excellent developer productivity and is so easy to use that you can learn it within a few hours.
That changes as soon as your application needs to handle a huge amount of data or if you want to guarantee very short response times. Features and concepts that work perfectly fine for smaller applications start to become a burden that slows down your application.
But that doesn’t have to be the case for your application. Hibernate is a great fit for complex projects with high-performance requirements. You only need to know which features to use and which you should better avoid.
During this talk, I will show you how to get the most out of your Hibernate-based persistence layer. By following these recommendations, you will be able to enjoy Hibernate’s developer productivity and provide a blazingly fast experience to your users.