Video

Nice approach to make full-stack life easier.

I thought that the combination of @Entity and @Data is discouraged.

The repository call in the domain object even does not guarantee the rule is not broken, because it's not transactional consistent... I think no-one should do something like that. There is a lack of some Availability concept in the domain.

Kotlin support ?

Any connection of Vaadin to Hilla ?

Truly excellent talk highlighting the many benefits of Kotlin. Thanks for also going into WebFlux and coroutines towards the end.

Ooh! Josh, my dear friend, is there any reason you never use @RestController?

Hey can i change the front end and make it an api??

Entity Framework in .NET does this sooo much better. Just create a class that maps the domain object to an entity...simple as that! The problem here is that decoratirs where a mistake in the Java World

Great talk. I agree with almost everything he said, one thing I have found out in practice though is that the last bit is tough: Keeping JPA out of your core when your DB is going to be a relational one creates a lot of extra boilerplate and loads of extra conversions/copies of objects. This can get cumbersome (but the price you pay if you don't do it is the coupling he mentions).

I find it kidna funny that we say that "classical layered approach" can work for small projects and then we try to show benefits of DDD on the same small examples. But sometimes (quite often) in big systems we choose verbosity to provide better clarity and reduce coupling. To me it was terrifying what happened to our domain by the end of the presentation.

Beautiful, thank you very much for your work. Excelente video, I learned a lot !

what a nice

Great talk! A couple of thoughts. Your statement about entity state and transactions is only true if Spring's "open session in view" is not enabled. I find there is a lot of confusion out there about the Hibernate session, transaction state, OSIV, and entity state. Along similar lines, the call to a repository save() method is unnecessary when updating an attached entity because of Hibernate change tracking, and calling save() leads people to assume that it persists changes, which (counterintuitively) it doesn't. (It adds/merges detached entities to the session/persistence context.) Regarding transaction scope, I would argue it is still too broad. Work for a single user/card should generally happen in its own transaction, at least in an OLTP context.

The thing i hate the most in this video - "Conluding...", i was so engaged didnt wanted him to stop.

Please don't enforce New UI on us. We'll pay you our money. Wait, we're already doing so.

Sadly this was 45 minutes of wasted time. People had to watch a commercial full of misleading information... 😢

Do any of you suggest implementing JOOQ to a project with Hibernate already implemented? Or is it more like a migration from Hibernate to JOOQ?

Seems like you do not fully understand Event Sourcing and the single-responsibility principle. Why make a video about it?

9:45 Why don't you use individual aggregates for technical and business aspects? Are you not using the Single-responsibility principle?

8:00 Why does the aggregate not fit? Could you please elaborate what is not fitting?

sorry, the topic and the presentation has,without doubt, a high technical value, but the english of this guy, the accent and the way he tries-hard to emphasise almost each and every word in the sentence comes highly unnatural.. it really sounds tiring in the ear

thanks for such a lovely session.

7:15 Those two rules are unclear. What happens to students who are over the limit when the limit gets reduced? Do they stay or get expelled? And if so, which students? Do they get notifications? Without any clarification, the situation is undefined.

34:00 Sounds like you're doing checks in the event store, that should have been done beforehand in the command handler.

Thanks for the presentation! Is a repository of non-DDD example of library available somewhere?

to generate random values to our mocks maybe you should use easyRandom or similia

Clear and detailed. Thank you for the efforts!

a very interesting project. I will be using it in future.

Roland's talk has been featured in the last issue of Tech Talks Weekly newsletter 🎉 Congrats!

Nice talk. Thanks.

excellent explanation. been struggling to really get it and this just made it so accessible. the info just passed all my brain's filters and is all sending back 200's! ;)

I've seen this presentation in portuguese before of Rafael Pontes in Zup Channel, and I could implement something similar it in my job. Great work, Bro! Thank you so much

At 12:09, do `that()` and `should()` really do anything? Or are they just some noop to make code sound English-grammatically correct? At 13:15, `resideInAPackage("...owner...")`: if we refactor the package names (e.g. no package has the word "owner" in it), then this test always passes. Why do variables (e.g. ControllerNaming, OwnerDependencies ...) start with a capital letter? If ArchUnit is written and used in Scala, I guess that those ArchRule can be written like this: classes that areAnnotatedWith Controller.class should haveSimpleNameEndingWith "Controller". This reminds me of ScalaTest which was thought to be cool about 7-8 years ago because of its DSL, but now I wonder how many percentage of Scala developers can stand that syntax.

Great content!

Thanks for the really comprehensive explanations

Can't say I liked it. In the very beginning we say, that our domain should be framework agnostic and yet we introduce jpa entities right into it. Next we implement BookSearchService in infrastructure. Oh wait, let's just put it in application package just because that's the rule. What is the difference between infrastructure and application then? When creating Loan domain, we introduce LoanRepository argument into its constructor. Why? And there's much more I don't get about it. In the end, even if somehow manage to understand it, how am I supposed to explain it to the others.

I dont understand the trend to make comparison amogn these two languages. Man can make safe and readable code in java & kotlin. All features are now available in both languages, it only differs in what it is called and the usage (for example extension functions you replace with util classes or use bytecode maven plugin for support it dirrectly). This comparision sessions are only for guys liking the smell of their farts (south park if you know :D)

Fantastic!

Can we debug that python code ?

Is there a repo for this code?

The more I hear about you, the more impressed I am. You are awesome!

the best thing about this session is that i learned spring security and Spanish both in best way

Nicely done @RafaelPonte.

Perfect talk, enjoyed it a lot

❤❤

Great presentation

this for me is the best presentation. Great job

Does a single @Transactional annotation for Scheduled method (in case of JPA framework) fix the original code right away?

Great presentation, great work. Thanks a lot for sharing this knowledge with us!