The speed of light is approximately 186 miles per millisecond. In a distance measurement application (e.g. radar) the round trip distance is 93 miles per millisecond. If each clock cycle is one millisecond, the distance can be no more precise than 93 miles. This realization argues for higher clock rates. A one megahertz clock improves range resolution to about a tenth of a mile; a one gigahertz clock improves range resolution to about six inches (e.g. ground penetrating radar).

By introducing a configurable clock, portability is broken even more than when we introduced *T0* in the previous post. To address the portability issue consider breaking the time into two parts: minutes and seconds. Let the minutes be referenced to a start minute *M0* at the same time as the clock counter is referenced to the start time *T0*. When constructing the timestamp object let us specify *M0*, *T0* the clock rate in Hertz and an implementation of the interface now(). This interface returns the raw number of clock cycles since some initial time as in the following example.

long now() {

return System.currentTimeMillis();

}

The product of the clock rate and 60 is the number of clock cycles in one minute. Let us call that value *ONE_MINUTE*.

Let us calculate the unsigned remainder (modulus) on dividing *now()* by *ONE_MINUTE*. Dividing the modulus by *ONE_MINUTE* yields a fraction of one minute between 0 up to but not including 1.0. The product of 60 and this value yields the number of seconds after the current minute, a portable value that is **independent** of the clock rate.

Subtracting the modulus from the dividend yields a value that *ONE_MINUTE* can evenly divide. The resulting quotient when added to *M0* is the minute of epoch. So long as everyone agrees on the epoch beginning, this value is also portable and independent of all configurable parameters.

The year 2000 is a leap year exception to the 100 year leap year exception to the every fourth year leap year. For that reason, I chose 2000-01-01T00:00Z as the epoch reference; named the minute of epoch *mm2K* and implemented the following functions.

Timestamp set(int mm2K, double sec);

int mm2K();

double sec();

# Advantages:

- Configurable time bases work with any clock rate
- Timestamps with different clock rates can be compared to one another

# Disadvantages:

- Integer division is computationally intensive relative to addition or subtraction
- Data exchange increases from 64 to 96 bits
- Still not human readable

# Suggested Use Case:

Creating timelines from different systems may require comparing timestamps with different clock rates. Since mm2K and sec are portable they are used to implement the interface java.io.Comparable<Timestamp>