Let’s Stop the Unix Time Insanity
creativepark.net
creativepark.net
There is simply no algorithm that accounts for their behaviour all the time. The best you can do is have one that works most of the time, and then have a table of exceptions (which has to be locale based).
For example, what date is 15330 days after February 30(!) 1712 in Sweden?[1]
In November 1699, Sweden decided that, rather than adopting the Gregorian calendar outright, it would gradually approach it over a 40-year period. The plan was to skip all leap days in the period 1700 to 1740.
Great.. except:
In accordance with the plan, February 29 was omitted in 1700, but due to the Great Northern War no further reductions were made in the following years.
Oops. Oh well:
In January 1711, King Charles XII declared that Sweden would abandon the calendar, which was not in use by any other nation and had not achieved its objective, in favour of a return to the older Julian calendar. An extra day was added to February in the leap year of 1712, thus giving it a unique 30-day length
But the Julian calendar sucks[2], so:
In 1753, one year later than England and its colonies, Sweden introduced the Gregorian calendar, whereby the leap of 11 days was accomplished in one step, with February 17 being followed by March 1
Once you start doing date work you'll find these crazy cases all the time. Try and tell me today's date on Mount Athos...
[1] https://en.wikipedia.org/wiki/Swedish_calendar#Solar_calenda...
[2] https://en.wikipedia.org/wiki/Julian_calendar
[3] https://en.wikipedia.org/wiki/Mount_Athos#Date_and_time_reck...
1. Precise timekeeping for dates over 100 years old is not usually required (though perhaps you work in an area that is an exception?)
2. UNIX timestamps are independent of timezones and can be easily mapped to and from local time by standard, well-tested libraries. The Olson database maintains tables of local time zone information for modern time zones: http://en.wikipedia.org/wiki/Tz_database
Here is some discussion of Mount Athos, not sure if this was ever implemented or not though: http://comments.gmane.org/gmane.comp.time.tz/1610
Agreed.
though perhaps you work in an area that is an exception?
Thankfully, no. These days I rarely have to deal with dates at all. I still have the scars though..
I find the anomalies extremely interesting for their own sake.
They aren't entirely gone in the modern world, either. Mount Athos is one of the weirder ones, but Ethiopia still uses a calendar similar to the Julian calendar[1].
More practically, though I suspect that in almost all places with non-conventional calendars you can probably use a normal Gregorian calendar too and people will convert for themselves.
I think, that he's seriously suggesting that we find a unit of time that can be guaranteed to just increment and not be subject to leap stuff or calendar adjustments and can go forward and backwards in time as simple increments and decrements.
A de-coupling between the time counter and our perception of time as a human concept.
Maybe use the concept of a second, but not in relation to our calendar. So instead of being "seconds since 1970" it's just "seconds".
I guess the idea being that you'd have a guaranteed increment only counter for seconds that have passed, but without coupling that to an actual calendar.
I'd probably ask what the problem was that created this thought, maybe there's an answer to that instead.
OP here. That article is old and I really wish it wasn't on the front page. If I remember correctly, at the time this was written, there were some pretty big outages and failures that originated from apps assuming time was pretty much a linear monotonic value. So the motivation to write this was not only for myself, but to attempt and find a better solution for timestamps as needed by many apps.
There is no technical reason for the timestamp to jump around, and to convert to and from "human" time we already need libraries (especially if we're looking at points in the past or the future), so the argument that system timestamps MUST map to actual time of day is somewhat moot. As it is, the Unix timestamp attempts to be somewhat in the middle, in the end satisfying neither computer nor human requirements. So the idea was to separate those two timing formats completely.
I think you mean "monotonic". Though lots of non-geeks would probably say that "monotonous" applies too. :-)
It's called TAI, International Atomic Time [0], and it's effectively just UTC minus the leap seconds. It's (close to) the actual time being measured by CPUs all about and it's a pain in the ass to convert to and from it due to leap seconds and such, but if you want to just make time somebody else's problem entirely then using TAI will keep you accurate at least.
Any counter you create will have a zero-point somewhere. 00:00 Jan 1 1970 isn't a point in time that moves around, same as any other zero point you elect to have.
I have sympathy for this view. Back when I was doing time & date stuff I worked out a decimal calendar as a thought experiment. If you are happy to drop the idea that a "day" has to align with a period of daylight, and/or the "year" has anything to do with seasons then it's pretty easy...
A single moment in time maps to a single UNIX timestamp and back again with almost no complications or exceptions (the only one I'm aware of being leap seconds, which is fairly minor). This makes it a great way to store and manipulate actual time.
It's then complicated, sometimes enormously complicated, to go from this simple representation to what humans would call a "date". But that's unavoidable, and by using something nice and simple like UNIX time in the backend, you ensure that all of the craziness when dealing with weird human systems stays at the front end where it belongs.
It's not always possible, of course. Some systems need to store "dates" in terms of what humans think they are, not actual moments in time. (For example, storing a birthday as UNIX time would be a bad idea.) But whenever you want an actual moment in time, UNIX time is great.
As you've pointed out, the problem comes from peoples misunderstanding that time durations are not easily discernible without looking up many, many exceptions in many cases. The best we've got is a simple absolute time, and very specific rules for determining what the human recognizable interpretation of that time was at a specific locale at that time.
The solution to this problem is simple; Change the way everybody reads and thinks about time. It's also, IMHO, impossible because simple ain't easy.
> I know there is a lot of smugness going on in developer circles where people get high on posting comments such as “of course it is like this. it’s the way we’ve done it forever, it’s the only way.”
What the author perceives as "smugness" is a reaction to criticism of the status quo without understanding and addressing the benefits of the status quo.
I'm not preemptively dismissing the author's proposal, but you would have to overcome some fairly serious hurdles. Most notably, you would not be able to reliably construct dates in the future, because it is not generally known when leap seconds will be added. So it is unknowable what the "monotonic timestamp" for Jan 1, 2023 00:00:00 is, for example.
I think a better answer to the problem is the leap second smear that Google has implemented: http://googleblog.blogspot.com/2011/09/time-technology-and-l...
> Most notably, you would not be able to reliably construct dates in the future
You already need libraries for these functions. The only difference is that right now, those libraries have to calculate against a moving target instead of one that behaves predictably. I wrote this post a long time ago to suggest a strict(er) divide between computer timestamps and human timestamps, because Unix timestamps are in effect neither.
There are countless apps that implicitly assume timestamps are linearly counted upwards. Most people would say those are bugs, but they'd only be right on superficial grounds. What most applications rightly want is a monotonic, predictable way to count the passing of time and to exchange that data with other apps.
My idea was to introduce such a linear counter for apps that want it, not (as some people here obtusely suggested) replacing the Unix timestamp with this no matter the ecosystem breakage.
I'm not sure if you caught my point. Library or no, it is impossible to construct future dates because it is unknown when leap seconds will be inserted until six months or so before it happens.
Leap seconds are based on minute changes in the rotation of the earth, which are unpredictable.
I added this to my comment later, but I think a better way to get a strictly monotonic timestamp is to smear the leap second: http://googleblog.blogspot.com/2011/09/time-technology-and-l...
> There are countless apps that implicitly assume timestamps are linearly counted upwards.
There are also countless apps that implicitly assume that minutes are 60 seconds, hours are 3600 seconds, days are 86,400 seconds. Your scheme would break these apps.
> Library or no, it is impossible to construct future dates because it is unknown
> when leap seconds will be inserted until six months or so before it happens.
> Your scheme would break these apps.
No it doesn't. I can tell you authoritatively that the UNIX timestamp for 2023-01-01 00:00 UTC is 1672560000. That value is not dependent on future changes to the rotation of the Earth.
Now it is true that I cannot tell you precisely how many physical seconds there are between now and then, because I do not know how many leap seconds will be added in the meantime. But in practice I think this is less critical. Applications that care about this probably use a more specialized time scale anyway. But it would be strange to put an appointment in your calendar for midnight and find that later on it had flipped to being at 11:59pm the previous day.
> Again, and I already said this multiple times now, the idea is not to abolish the Unix timestamp and ignore whatever breaks. Instead I suggested to introduce a linear counter for apps that want it.
I understand what you are saying. I'm just saying that your proposal trades one surprise for another. An app author might think "oh yes, a monotonic time sounds nice" and start using it, only to find that they are broken later because they were surprised that a minute could be 61 seconds long.
That assumes the calendar definition does not change. What if a 10 month calendar with a new year that starts in spring somehow becomes widely popular and adopted as the standard sometime in the next 10 years?
Then suddenly 2023-01-01 is not 1672560000 and is actually 1680332400.
If you wanted to use a different calendar, you would need to map it to Julian days also to convert between the two.
The idea that the world would suddenly change to a new calendar is highly unlikely, and if it did happen it is not at all clear what the correct behavior would be for future dates that had been specified before the switch.
The UNIX timestamp for 2023-01-01 00:00 UTC is 1672560000. I can tell you that right now even though I do not know how many leap seconds will be added between now and then.
If you assume that system time is a continuum I have some bad news for you: system time is actually a user preference. Users can change it any moment to whatever they feel like, no time machine required. Given that, leap seconds are small potatoes. If you propose we change this and take away user's ability to set system time... well, there might be some merit in this from purely theoretical point of view, but in real world where batteries die, clocks get out of sync, and tons of software already rely on existing behavior - I don't think your proposal is likely to get very far :-)
Now, if you want a continuum, it's already there: look up CLOCK_MONOTONIC.
So yeah. Maybe I'm missing something obvious, or maybe the author is referring to another random set of 4 words?
I realize we've been stuck with the Unix timestamp for so long it's become somewhat impossible for many to acknowledge the points where it breaks.
The time used for "Unix Time" is actually UTC, which is a standard that is specified in international standards that predate Unix. It is specified in current international standards for everything from aviation to HTTP requests.
If Unix tried to use something else, you'd generate massively more confusion for every Unix developer as they were having to figure out the current conversion to what is actually required for interacting with the rest of the world.
Unix Time is not UTC; it is a linear representation that is surjective onto UTC. It is easy to map between the two but they are not the same. They are not even isomorphic or bijective because leap seconds have no unique representation in Unix Time.
The Unix Time representation gives up full equivalence with UTC in order to provide some useful guarantees (days are always exactly 86,400 seconds long, midnight always satisfies x % 86,400 == 0, etc), but also creates other surprises (time can go backwards when a leap second occurs).
I'm not too familiar with what the clock situation is like for languages outside C/C++/Java.
If you want a human timestamp, use gettimeofday[0] and related functions. If you want something to compute actual elapsed seconds with, use high-resolution timestamps([2] and [3]). You just can't have both, and that's because of the way human dates work, not the way we represent them.
[0] http://pubs.opengroup.org/onlinepubs/009695399/functions/get... [1] http://www.lehman.cuny.edu/cgi-bin/man-cgi?gethrtime+3 [2] http://pubs.opengroup.org/onlinepubs/9699919799/functions/cl...
The Future of Leap Seconds http://www.ucolick.org/~sla/leapsecs/onlinebib.html
See especially the 'Distinguishing the two different meanings for time' section. It makes a good distinction between time-of-day and time interval. Unix time measures the first.
Toward that end, unix time is totally usable, as long as you make the assumption that all unix time was created in a specific space and time. Then you just have to calculate what your observation of it is. That way, two bodies sitting next to each other may calculate the time that applies to them, and communicate by simply returning the time to the standard before comparing with other bodies.
(Apparently this already exists; the Einstein synchronization procedure defines a method to establish universally (in the astronomic sense) temporal coordinates, which is in effect both location and time)
That is true except in the case of leap seconds, in which case UNIX time is not monotonic or continuous.
> Leap seconds are just our immature way of dealing with time dilation.
Leap seconds have nothing to do with time dilation. TAI, on which UTC is based, is defined as the passage of proper time on Earth's geoid. This gives a stable base that is not influenced by the frame of the observer. UTC does not change based on where you observe it from. It is the same on Earth, in space, etc. regardless of your frame. None of this has anything to do with leap seconds.
Leap seconds compensate for the fact that a mean solar day is slightly longer than 86,400 seconds, and can vary slightly due to irregularities in Earth's rotation. Leap seconds are added to keep UTC noon within a second of mean solar noon at the prime meridian.
> You can always add or remove time as an observer to conform to whatever your view of time is in relation to that older fixed point.
UTC is defined at the geoid, and everybody uses UTC seconds even though they are slightly shorter than seconds as observed by most people on Earth.
If you want to learn more about leap seconds read: http://www.cl.cam.ac.uk/~mgk25/time/leap/