3.17 years.

> I believe the most spectacular event is going to be the Unix timestamp 2 000 000 000 which is still 9½ years away: 2033-05-18 03:33:20 UTC. Such an event occurs only once every 33 years 8 months approximately!

Egads! 33 years! I spent my late 90:ies mudding[0] and for some reason we had a lot of save files named by their epoch timestamp. When I ended up responsible for parts of the code base, I spent a lot of time dealing with those files, and they were all in the 800- or 900- million range. At some point I was pretty much able to tell at a glance roughly what date any number in that range corresponded to, within perhaps a few weeks.

Weird environments foster weird super powers.

[0] https://en.wikipedia.org/wiki/Multi-user_dungeon

The spectacular events is in Jan 2038, when it reaches a nice round number of 2,147,483,648

I think 2222222222 is more special Sat Jun 02 2040 03:57:02 GMT+0000

I might even get to experience 3333333333 if I am lucky. What a day, what a day, yes indeed!

I used to follow your blog about 15 years ago, what a blast of nostalgia! I’ll add it to my RSS feed. Keep it up.

That website gonna crash so hard on Tuesday…

“Boss! We’re being dee dossed!”

“No, son, it’s Tuesday”

You know how you can use a "death clock" to figure out when you should statistically expire?

I wonder if you can find a shirt that would print that

This is quite clever. I'm going to get one.

This reminds me of an idea I had - the 1BTC coffee mug - this was back during the early first rise to $20k.

internet is really wonderful sometimes

Timestamp 1000000000 (Sat 2001-09-08 18:46:40 PDT) triggered a bug in the bug reporting system (Remedy) we were using at the time.

The system stored timestamps as a string representing seconds since the epoch, but it assumed it would fit in 9 digits. At 1000000000, it started dropping the last digit, so it went back to Sat 1973-03-03 01:46:40 PST, advancing at 10% of real time. It was fixed fairly quickly.

I didn't remember it was so close but those were the days I obsessively read Slashdot, which helped during 9/11, and which certainly covered the epoch event.

please explain

I was doing the late shift on a trading floor at a big bank.

The head of the derivatives tech support team pointed out it was about to hit so we opened up a shell and did a "watch" command + outputting the "date" command in epoch seconds and watched it happen.

Then we went back to working.

I remember that moment! I was out at a bar or something at the time but I was prepared and had my laptop with me haha. I was mashing the up arrow and enter to make sure I didn’t miss it.

Yes! It is as a direct result of that book that I now know without having to look it up that a ksec is about a quarter hour and a Msec is on the order of a fortnight, which comes in handy when doing back-of-envelope estimation more often than you'd expect. (I'd already known that a Gsec was about a third of a century thanks to Tom Duff's observation.[0]) I don't see us moving to such a system anytime soon in general (tying to the circadian cycle is just too convenient) but I'm a little surprised I don't see it more often in discussions of humans in space.

[0] "How many seconds are there in a year? If I tell you there are 3.155 x 10^7, you won't even try to remember it. On the other hand, who could forget that, to within half a percent, pi seconds is a nanocentury." --Tom Duff

Though the software archaeologists in the book mistakenly thought the time_t epoch marked the moon landing, not just 1970. :)

I also like the Emergents. Liberal progressives creating a utopia. 100% employment, palaces made out of diamond for everyone.

Reminds me of sdate for the Eternal September epoch. 10000 Sep 1993 was 2021-01-16.

http://www.df7cb.de/projects/sdate/

one commit message for the QDBs:

    From 14df411817feda9decf9dd8a6cd555d71f199730 Mon Sep 17 00:00:00 2001
    From: Christoph Berg <myon@debian.org>
    Date: Thu, 4 Jun 2020 20:05:49 +0200
    Subject: [PATCH] Fix long --covid option
    
    
     scripts/sdate.in | 2 +-
     1 file changed, 1 insertion(+), 1 deletion(-)

Sep 17 2001 (1000684800) is a special date from git-format-patch. Its significance is lost to time.

This might interest you, if you haven't already seen it: Unix timestamp clock, in hex! https://retr0.id/stuff/2038/

FWIW these bash shortcuts are handy if you do this a lot:

    tss() { date -Is -u -d @$1 ; }
    tsm() { date -Ins -u -d @$( echo "scale=3; $1 / 1000" | bc) | sed -E -e 's/[0-9]{6}\+/\+/' -e 's/,/./' ; }
    tsn() { date -Ins -u -d @$( echo "scale=9; $1 / 1000000000" | bc) | sed 's/,/./' ; }

    $ tss 1700000000
    2023-11-14T22:13:20+00:00

    $ tsm 1700000000000
    2023-11-14T22:13:20.000+00:00

    $ tsn 1700000000000000000
    2023-11-14T22:13:20.000000000+00:00

Because the bases are all wrong. Common number bases are 10, 16, maybe 8 if you live in the 70s, and 2.

Except for the utterly unwieldy binary, none of those bases adapt well to the bases used in representing time, which are mostly the (partially related) bases 60, 12, and, annoyingly, thirty-ish.

So you always end up doing opaque arithmetic instead of “just looking at the digits” (which you still can do in decimal for century vs years for example, because we defined centuries to be exactly that).

> I've always loved the idea of measuring time in computers by a single integer like the timestamp does

Why?

>The Unix epoch is midnight on January 1, 1970. It's important to remember that this isn't Unix's "birthday" -- rough versions of the operating system were around in the 1960s. Instead, the date was programmed into the system sometime in the early 70s only because it was convenient to do so, according to Dennis Ritchie, one the engineers who worked on Unix at Bell Labs at its inception.

>"At the time we didn't have tapes and we had a couple of file-systems running and we kept changing the origin of time," he said. "So finally we said, 'Let's pick one thing that's not going to overflow for a while.' 1970 seemed to be as good as any."

https://www.wired.com/2001/09/unix-tick-tocks-to-a-billion/

Or roughly every 136 years.

How so?

Sure there is. But since it is not a continuous range there are the fixed separators --T::. between the parts. It is the javascript time format, which is a subset of the RFC3339 and ISO8601 time formats. The separators help at least to allow for a variable amount of sub-second digits.