How do we usually manage time in applications ?
Timers, threads, concurrency locks…
If we want to practice Domain Driven Design, we’re surely at the wrong level of abstraction.
What is time, btw ?
Tricky question. We know what time is, but… giving a definition is not that easy.
What defines time ? The second ?
Not really. It is used as a measure of time, but it doesn’t seem sufficient.
Let’s have a look at Wikipedia’s definition of time :
Time is a part of the measuring system used to sequence events, to compare the durations of events and the intervals between them, and to quantify rates of change such as the motions of objects. […]
Now we have something interesting : Time is what happens between events.
But what is this thing between events.
The definition of the measure unit surely can give us further insight.
Lest have a look at Wikipedia’s definition of the second :
[…] Since 1967, the second has been defined to be
the duration of 9,192,631,770 periods of the radiation corresponding to the transition between the two hyperfine levels of the ground state of the caesium-133 atom.
The second is defined as a count of transitions between states of an atom of cesium.
We measure time by considering that the ~time~ between those state transitions is constant.
What if it’s not ?
It’s not that important if other events seem synchronized with those events. Will come back to this later.
Let’s step back a bit.
How do you feel time passing ?
By looking at your watch ?
Maybe, but how could you explain that an hour sometimes seems so long, and sometimes passes in a flash ?
Time seems slow and empty when you’re bored.
Times seems fast and full when you’re busy with interesting things.
When you’re bored, it’s because few interesting things happen.
You can deduce from this that your personal state transitions are those interesting things that happen.
These are meaningful events. Things that happens and change you deeply.
Of course a lot of things happen between those meaningful events, you’re moving, thinking. Your blood flows through your body, but it is just maintenance move. You don’t change deeply.
Maybe some things happen between state transition of a cesium atom, but since we cannot notice it and give it a meaning for now, it has no influence.
But when when a meaningful event happens, you change. You’re not the same before and after.
This is what time is about, and this is why it’s one way.
Before –> Event –> After
Events define time by causality
This perception of meaningful events is surely a reason why people say the time pass faster when old. In your 6 first years any event around you is meaningful. Any event make you change since you have no previous knowledge. Then has time goes by, you integrate knowledge and filter things you already know, you’ve already seen. When old, a year can more easily seem the same than the year before.
But some people continue to enjoy and learn as much as they can to still have a long now.
When do your system change ?
Your system never change for no reason.
It’s always because a meaningful event happened.
This event can be a user interaction, a call from an external system, a sensor trigger…
And when things change because it’s midnight ?
It simply means that midnight is a meaningful event in your system.
Where are those meaningful events in your code ? Hidden in infrastructure code ?
I hear Greg Young say :
Make the implicit explicit !
And it’s simple :
Use Domain Events.
Once you’ve introduced Domain Events in your domain model, you have made Events and so Time explicit in your domain.
There is no change in the domain that is not due to an Event.
The events appear everywhere in the Ubiquitous Language :
- When the client HasMoved to a new location, send him a welcome kit.
- When a RoomHasBeenOverbooked try to relocate the customer
- Every day at midnight = MidnightOccured, change last minute prices.
I’m sure you can find examples in your own domain. If your domain is business related, it has to deal with time because business is about time and money.
Time is now part of your Ubiquitous language and you have an implementation for it.
And that’s huge.