saying also this is a behavioral
pattern because it tells you are
like states how the behavior has
to happen or should happen
and it's always used so it's used not only in one of the controller
but it's used in dozens of places so whenever
the object needs to be updated because some user interaction
happened or something happened it doesn't need to be user interaction
might also be some internal state change then
we need to update some other things most often
yeah this is basically like little messenger going
around saying hay something happened and how we implementers
is serve shown here so so we have basically we kind of stall
on your services dependent objects on in the list
of observables in with the subject on this is basically
on down like this in this metre level
on and then we have to complete subject which is
model and this kind of implements this whole
subject and it has map update value can install some sort of
value and then it has some of the updated and and updates is
where you and when ever it updates so that you did not if us
all observables i did something i change something he's react
these react and then there's a couple of variance
again so you can be done but
the push notifications of the model tends
the observer's eye a change that are very
all the observer says you change something what
did you change it to me that would be kind of the pulmonary
and workable both of them in a in a colleagues
so not too hot and really have yes so we have
on the strategy that unless we already set and so
basically strategy that kind of
and actually it's algorithms in logic logic
in in a certain concrete strategies in several several
variants of the strategy that several of algorithm in each
in a class ok so this is once again quite abstract
so for example we might have a algorithm
which finds out of the area of the smallest
integer in there so something like find the minimum value something
and you could do this with different
implementations for example like just going all over it and
looking for the minimum or you could just
split and then in the middle and then such posts
parched on their own and then compare back so
there might be different implementations
to do the same job and they might be more or less you did on
a certain problem so therefore we could have different strata
these how to implement the same logic and we might into change
them at runtime in this case exactly so whenever we kind of
means something which was which really asks for all kinds
of search her then do but the search if it asks
for binary search and do that yeah so basically we're going
with this we're just able to exchange as the way we're doing
something as long as we know what we want to do
so and finally we got a constant pattern becomes
apparent kind of says it basically this tree structure
so on it has component and
each component can either
composite components which can contain other components
we all and might contain other competences of the tree structure
used on their all it is leavin that's kind of
the the basic thing so in a tree structure the leaders
at top and there's nothing growing have leave anymore except for