JVM Weekly #7 - Everything you wanted to know about Event Sourcing on the JVM*

(*But Were Afraid to Ask)

1. Do you already know how to do Event Sourcing?

I don't know if you also have this impression, however I believe Event Sourcing (and CQRS) have become the 'default' recruitment question when verifying a candidate's knowledge of System Design topics. On the one hand, this makes a lot of sense - in today's highly fragmented world, Event Sourcing, with its monotonicity and orderliness, appears to be a panacea for many problems. However, I have the impression that not only candidates but also recruiters often pretend to know what it is all about. Event Sourcing is such a complex subject that it is difficult to prove your knowledge of this architectural pattern in a simple (not simplistic) way. At the same time, however, sitting on the other side of the table (or rather, as for the 2022, screen), it is possible to ask in-depth questions effectively enough to detect whether a candidate is tapping into our learned rules.

But that results when a recruiter asks for things that aren't in production.

It is gratifying to see that many people in our industry have taken it upon themselves to spread the word about Event Sourcing. I will admit that it wasn't until reading Mr. Klepmann's wonderful 'Designing Data-Intensive Applications' that I racked my brain where Event Sourcing has its place in the 'taxonomy' of data storage approaches. At the same time, while Martin's examples are great for laying out the theories in my head, there is a lack of insight into potential implementation.

This is why I wanted to drop you a repository today EventSourcing.JVM by Oskar Dudycz. It is a stand-alone course that will take you step-by-step through a series of exercises, showing you the basics and the grind of how Event Sourcing-based systems should be developed. You will also need to read a selection of texts on this application architecture to get them right. EventSorucing.JVM is a good mix of knowledge pill and practice that I suggest trying for those who want to understand all this Event Sourcing.

In general, at this point, I would also like to recommend Oscar's ongoing newsletter: Architecture Weekly. I read it regularly myself, and it is one of the few good things that the pandemic left behind - as the whole thing started to be published at the end of 2020. I still remember the original version and the need to follow the whole thing through GitHub releases. I'm glad the project has evolved so much since then.

From Oskar, I snapped the lovely picture above.

Sources

• EventSourcing.JVM

• Architecture Weekly

2. Problems with dependency management in Java

Dependency management in Java is like electricity, the post office, or rubbish collection - a part of our infrastructure that we don't appreciate until it "just works." However, all it takes is for something in the whole complex mechanism to snap momentarily, and we are immediately reminded of how important they are to our life and health (including mental health). And while no one is likely to get into the details of utilities daily, understanding the ins and outs of dependency management can help us avoid getting kicked in the knee in our daily work. This is because Java has quite a few mechanisms that work in this area. Both those that actively lead us by the hand and those that, when used incorrectly, can lead to non-trivial errors.

The image above is of Python, but I put it here for attribution and a sense that others have it even worse.

The holistic view of this whole ecosystem is the focus of Renato Athaydes' text: The difficult problem of managing Java dependencies. I promise you that after reading it, you will start to appreciate how much the tools do for you and how many non-trivial situations they are forced to solve. The whole thing breaks down the Maven and Gradle builds into their essentials, showing what is happening underneath them. There is also plenty of room in the text to look at JPMS (aka Jigsaw aka Java modules) and assess how much it helps keep these more complex applications stable. The article also directly compares Java to the direct competition (here mainly Rust Cargo). It looks at what new ideas have emerged over the years in 'more modern' languages than Java and whether they have solved the dependency management problem better.

And while we're on the subject, let me throw up again a series Jar Hell, which has already been featured in our reviews in the past. Still, it's a great Deep-Dive into the issues of ClassPath and how the mechanisms involved work. This sort of thing just doesn't get old quickly.

Interestingly, this is not the only text with this title, another one was written by Nicolai Parlog, who is well known from the previous edition. It is apparent that this topic is deeply painful for many.

Sources

• Jar Hell

• The difficult problem of managing Java dependencies

Rumor: Layoffs at Oracle

Due to a year-on-year revenue decline of 28%, Oracle executives are reportedly keeping an eye on a US$1bn cost-cutting program that involves reorganizing the organization and laying off thousands of employees.

According to rumors, the redundancies are expected to occur as early as August, with mainly more experienced employees being replaced by a younger 'workforce.' For the time being, these are mainly just rumors, but more and more announcements on this topic are appearing on the web. It is unclear to what extent such a move might affect Java as such.