design-patterns | design patterns for software development | Architecture library

In essence you don't need to include either header into the other. This fixes the circular includes. In ROS_Topic_Thread.h, friend class Master_Thread; already forward declares Mater_Thread, so you don't need the Master_Thread.h header. In Master_Thread.h, you can also forward declare class ROS_Topic_Thread; before the declaration of the Master_Thread class, since you only use references to ROS_Topic_Thread in the transfer_to_master_buffer method.

Ok i think the comments are right, the way i see the solution is the following :

No Setter, the only way to interact with the object will be with function with a purpose. For exemple, modify HP, add a DoDamage function that will return false if the ship is destoyed and will internally modify the hp (and maybe the damage too, etc..)

Getter can be public, but of course, only "const &"

Clone method is a good idea for future development (prototype pattern)

The two are compatible patterns that address different problems, Sagas handle workflow processes where as event sourcing addresses how state is stored. Sagas provide a mechanism for handling a multi-step process and rolling back should steps fail (like a workflow). Where as Event Sourcing is the process of encoding the state of an entity by recording all its past changes.

Lets say we are booking a holiday, we need to book flights, a hotel and hire a car. each of these processes is handled by a different microservice.

We could create a microservice named BookingSaga which would be responsible for keeping track of the state of each booking. When we make a booking the BookingSaga service would

• book the hotel
• book the flight
• book the car

these can reply in any order, but if any one fails the BookingSaga would then begin a rollback and cancel any that had already been booked.

https://microservices.io/patterns/data/saga.html

Event sourcing keeps track of the state of some entity by recording the changes that have happened to it.

• Object A Name changed to "dave"
• Object A Age Changed to 3
• Object A Named changed to "sue"

So we can see that Object A has a name of "sue" and an Age of 3 at the end of all the events. https://microservices.io/patterns/data/event-sourcing.html

A fundamental trade-off between these choices in a broad sense has a name: "the expression problem". You should find plenty on Google under that name, both in general and in the context of Rust.

In the context of the question, the "problem" is to write the code in such a way that both adding a new state and adding a new operation on states does not involve modifying existing implementations.

When using a trait object, it is easy to add a state, but not an operation. To add a state, one defines a new type and implements the trait. To add an operation, naively, one adds a method to the trait but has to intrusively update the trait implementations for all states.

When using an enum for state, it is easy to add a new operation, but not a new state. To add an operation, one defines a new function. To add a new state, naively, one must intrusively modify all the existing operations to handle the new state.

If I explained this well enough, hopefully it should be clear that both will have a place. They are in a way dual to one another.

With this lens, an enum would be a better fit when the operations on the enum are expected to change more than the alternatives. For example, suppose you were trying to represent an abstract syntax tree for C++, which changes every three years. The set of types of AST nodes may not change frequently relative to the set of operations you may want to perform on AST nodes.

With that said, there are solutions to the more difficult options in both cases, but they remain somewhat more difficult. And what code must be modified may not be the primary concern.

As the linked issue says in the comments:

Well... that's the optimistic part. The optimism is that it is safe. If you have to be certain it's safe, then that's not optimistic.

The example you show definitely is susceptible to a race condition. Not only because of thread scheduling, but also due to transaction isolation level.

A simple read in MySQL, in the default transaction isolation level of REPEATABLE READ, will read the data that was committed at the time your transaction started.

Whereas updating data will act on the data that is committed at the time of the update. If some other concurrent session has updated the row in the database in the meantime, and committed it, then your update will "see" the latest committed row, not the row viewed by your get method.

The way to avoid the race condition is to not be optimistic. Instead, force exclusive access to the record. Doveryai, no proveryai.

If you only have one app instance, you might use a critical section for this.

If you have multiple app instances, critical sections cannot coordinate other instances, so you need to coordinate in the database. You can do this by using pessimistic locking. Either read the record using a locking read query, or else you can use MySQL's user-defined locks.

Question #1.

1. No.
2. No.
3. Sometimes UML obfuscates a thing more than it clarifies a thing.

Question #2.

1. I only see one factory interface in the Grand picture. I don't see a separate interface.
2. ?
3. Yes. And no.

Question #3. No.

Question #4. No.

I'm not as up on my GoF patterns as I used to be, but I'll take a shot at this. I think you are correct about the difference. The GoF pattern uses inheritance for polymorphism and Grand's example uses conditional logic for polymorphism.

The operational difference is that to add a new type in Grand's example, I would modify the method createImage:

The Zalgo situation the author is referring to would be

I suggest looking into the Chain of Responsibility and the Builder Pattern specific for validation. See here:

• https://medium.com/@aleksanderkolata/java-tips-01-handle-validation-in-an-elegant-manner-using-chain-of-responsibility-design-pattern-ad3dcc22479e
• https://medium.com/henrydchan/input-validation-using-design-patterns-9d7b96f87702

You could also look into usage of the Decorator Pattern:

• https://www.google.com/amp/s/robdodson.me/javascript-design-patterns-decorator/amp/

Is there a way to do this that is both safe and explicit?

But before considering one of the patterns which might of course provide more flexibility but also more complexity consider if your rules might really get extended a lot and will be reused and that many cases. Otherwise it might be a bit of over engineering to go with one of the suggested patterns right away.

Also, you can make a lot explizit by using meaningful function names that explicitly tell the reader of the code what specific use case is being performed. Such a function than acts more like an orchestrator of the required validation steps. So your approach (despite of the bad name someTask()) might already fit your needs.

But this is unsafe because there is nothing stopping me from running validator3() and throwing an error if condition 2 hasn't been met.

You could either have each validate exception throw an exception or introduce guard clauses having the major task return if one of the validations fail.

Another option would be to pass in or register a list of validations with the same interface and loop them through. If you need to check for all validations and collect the results (e.g. error code or messages) for each validation step or throw an exception on the first validation is up to your needs.