Видео

Thank you 🙏

Thank you

Yes, of course. Orchestration is preferable when we are dealing with typical request/response scenarios or well-defined workflows. The higher level of visibility and control it offers comes at the expense of a single point of control, which might fail and could also reduce throughput. On the other hand, choreography shines when we want to model our system as pipelines using a pipe-and-filter architecture. In this approach, we receive an input and let it pass through a series of independent steps, tasks, or filters that can be developed, deployed, and scaled independently. This kind of architecture allows greater decoupling and typically achieves higher throughput because it renounces the central control offered by the orchestrator. Imagine having to build a system for a stock exchange where thousands of orders are coming in simultaneously. If we modeled this system using orchestration, we’d likely create a bottleneck at the orchestrator, where all orders must pass through a central component to be dispatched to the relevant services for tasks like validation, matching, and execution. The orchestrator could quickly become overwhelmed, slowing down the entire system. With choreography, each order can flow naturally through the system. For example: Order Received -> Validation -> Matching -> Execution When an order is placed, it triggers an event that multiple services can react to. In this model, each step is independent, with no central component orchestrating the workflow. Services scale independently based on demand-for instance, validation might require more resources during high trading volumes, while matching remains constant. This approach reduces bottlenecks, improves fault tolerance (since no single component controls the flow), and supports the high throughput required by a stock exchange. Choreography makes sense in such a scenario because it lets the system handle a massive volume of events without relying on a central controller, allowing the system to process orders efficiently and scale flexibly.

This is a great comment! As usual, it's all about trade-offs! I'll just give you my honest opinion. We expect transactionality to be handled by the infrastructural layer or adapter. ACID transactions are a core feature of most database engines, so re-implementing them within our application's core would be redundant. The simplest approach is to add the @Transactional annotation on AccountService.withdrawFunds (which is the concrete implementation of the use case). Some might argue against using a Spring annotation in the core, but this concern seems misplaced to me. The annotation doesn't tie us to a specific transaction manager or database. It just declares that the method's operations should execute within a transaction. As for testing, this approach means that concurrency testing would primarily be handled through integration tests rather than being confined to unit tests within the core layer. Could we avoid using Spring @Transactional in the core? Certainly! We could replicate its behavior or adopt patterns like Unit of Work, two/three-phase commits, or optimistic locks (which are similar to what you described). This would eliminate the Spring dependency, but does the gain justify the complexity? In my view, it doesn't. In a distributed system, you eventually need to rely on the infrastructure to coordinate operations across multiple threads and processes. There's no way round it.

Just came to mind that you could even use the Jakarta @Transactional instead of the Spring one, and still have it being recognized by the framework. docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

​@@MarcoLenzo Thanks a lot for the comprehensive answer. This makes a lot of sense. I was not aware that using the @Transactional annotation (JTA or Spring) might be an option. I thought that it might be "forbidden" in the core application. And I also was not sure that it would work after mapping from Account JPA Entity to Account Domain Object and back and then updating in the database. This ties your repository adapter implementation to a JTA aware implementation, if you want to handle transactionality. The MongoDB or HashMap implementation would behave differently from the JTA implementation for this concurrent call use case. So you need to know about the restrictions of your adapters for the driven ports, but this always applies (e.g. local file access vs. reading a file from a network). It seems to be another leaky abstraction problem. But as you said, it is a trade-off and probably not worth the effort to remove it.

That's a fair point. Avoiding over-engineering (or complex solutions) is possibly the most important thing when developing software. It helps us deliver more quickly a system that's also easier to operate and extend in the future. Both functional and non-functional requirements typically determine if asynchronicity is really necessary. However, my gut feeling is that if you are fine with two microservices talking over API synchronously, there's a very high chance that those two components could be merged in a single deployable where code is segregated with proper modularization. Obviously, each case is different and there's no right or wrong: just trade offs. :)

Too kind!

Thank you

Yeah we'll see it later in the course how we can leverage several implementations of the Container Storage Interface (CSI) to manage our persistence. If you want to read ahead of time, a lightweight solution is Longhorn which is what I use in my home lab. It takes care of creating multiple copies of a volume in different nodes allowing pods (and containers) to be scheduled in any node even if they require persistence. Hope this helps

Yeah, I totally agree. It's a new feature from RUclips and it surely needs refinement!

Do not hesitate to contact me on my email if you need more support 🙏

Are you sure? I just checked and there's still a free plan

Hi :) Feedback taken and appreciated! 🙏 I'm doing my best but in the meantime I'm making sure to have all new videos with manually corrected subtitles. I just noticed this video does not have proper subtitles. I'll make sure to update it. I'll also cover other popular videos of mine. Have a great day!

Thank you 😊

Thank you 🙏

Good evening!

Thanks for liking

Download a sample project. I have one linked in the video description and start from there. There are many more available scaffolds out there. If you're still stuck, contact me over email. You find the contact on my website.

Thank you!

Correct. Let me explain why I say the saga is an alternative to a distributed transaction. (Either / or) I say alternative because if you can afford doing distributed transactions, there's less value in adopting a Saga pattern. That said the two approaches could coexist but I see it as a rare scenario.

@@MarcoLenzo yes, in my opinion,nowdays xa is not the first consideration in distributed tx for its poor capacity. in jdbc scenario, other solutations like Seata(AT mode) is better.

@XiaolongLu-j1t Thanks a lot for sharing. I never used Apache Seata. You gave me something new to learn!

Thank you

👍

💪

Pleasure

IntelliJ IDEA is my primary IDE and I use Codeium on it. If you prefer JetBrains IDEs, just give it a shot and see how it works for you.

🙏

Have a nice day you too!

Thank you 🙏

Good one! 😆

Thank you!

👋

Thank you

I did have a few errors lately. However, they don't seem to affect the IDE negatively. Hopefully, they'll be solved in future updates.

Hi, excuse me for the late reply. I'm not sure I understand your problem with the item set. Why don't you want it in the aggregate? It's fine having it there.

Hi! Excuse me for the late reply. Why don't you want the item set in the aggregate? You can have a set or list of VOs in an entity or aggregate.

Thank you!

Glad I could help

You are correct. JetBrains AI Assistant enjoys a way deeper integration with their IDEs than the competition. This is the reason why I keep testing it. I use JetBrains IDEs and if their assistant was on par with the competition I would happily use it too. Unfortunately my experience has never been extremely positive with their assistant. I'll keep on giving it chances though. More or less I experiment with it every quarter :)

Yeah I agree.

As far as I know there are no limits when you use their base model. Limitations are on the use of other models like GPT4, etc.

Let me know if you are interested in a particular topic and I will do a video on it.

If you notice, RGBColor is a Java record. In Java records, all fields are (implicitly) final and there are no setters to foster immutability. Give it a try and let me know.

@@MarcoLenzo what is setRed setBlue and setGreen? They r not setters?

Oh now I understand what you are referring to. Those are examples of side-effect free functions. They are not typical setters. Maybe I should have given a different example naming the functions differently to avoid confusion. The idea is that VOs are not data containers with no behavior. It is fine for them to implement functions that act on its state. However, when this happens, we need to enforce immutability, thus we are forced to return new instances. This way there is no risk to change the state of some other object that was holding a reference to the initial VO. You can find this concept explained in the book by Vernon "Implementing DDD" in the chapter dealing with Value Objects. Hope this clarifies it. Excuse me for the poor example. Also search the web for side-effect free functions and you'll find a lot of material. I'll try to cover them in another video.

@@MarcoLenzo yes please, would b great

Agree