All right so let's try to summarize some of the things that we've learnt about the observed design pattern.
So first of all we saw that there are typically two participants to the observable design pattern so
you have the observable itself which is basically a component which explicitly provides a way of subscribing
to some of the events or signals that it actually uses.
And then there is the observer.
So the observer is the thing that performs the subscription so it subscribes to changes.
For example in some component and then it gets the notifications.
So we saw that typically the observable implementation is intrusive.
Which means you take the mobile so you have a class called Person For example you need to modify that
class in order to support the idea of becoming an observable.
Now in the case of the observer it doesn't need to be intrusive.
So we certainly did it in an intrusive way by having as separate the interface kind of an observer the
interface.
But you can do without it.
You don't need to observe the interface you can just generally have a Alamdar for example that subscribes
to a signal.
So we also saw certain problems with multi-threading and reentrancy that can cause issues so you need
to think ahead and be very careful in terms of how you actually handle the whole thing.
And finally we saw boost signals and there are other ready made the implementations of the observed
design pattern we can simply download and start using straight away.
But when you do be sure to read the documentation because for example boost signals is not thread safe
so that's why I didn't go in-depth with it because essentially if you want thread safety net Well you're
going to be implementing this yourself.
Unfortunately.