Unix Time: The Universal Clock of Computing

If you’ve ever wondered how computers keep track of time across different time zones, operating systems, and programming languages, the answer lies in a simple yet elegant concept called Unix time, also known as epoch time, is formally defined in the POSIX standard and documented extensively on Wikipedia.

So what exactly is Unix time?

Unix time is a system for tracking time as a single number: the count of seconds that have elapsed since January 1, 1970, at 00:00:00 UTC (Coordinated Universal Time). This moment is known as the “Unix Epoch.”

For example, as of writing this article in late January 2025, the Unix timestamp is approximately 1737849600 seconds. That’s over 1.7 billion seconds since 1970!

Why count time this way?

Before Unix time, different computer systems had their own ways of representing dates and time, which created chaos when systems needed to communicate.

Unix time fixed this with a very pragmatic idea:

• represent time as one integer
• store everything in UTC
• convert to human-readable formats only at the edges

This gives you:

• simple storage
• easy comparisons (t2 - t1)
• no ambiguity across regions
• fewer bugs in distributed systems

Where you’ve already seen this

Git Commits

Git stores commit timestamps as Unix time, recording when each change was authored and committed as seconds since the Unix epoch. These numeric timestamps make it easy to sort, compare, and reason about changes across branches and repositories, regardless of time zones or platforms.

DNS TTL & Cache Invalidation

DNS records include TTL (Time To Live) in seconds. Resolvers calculate expiry as query_time + TTL using Unix timestamps. When Cloudflare or Route 53 evaluates DNS cache validity, resolvers compare the current Unix time against stored expiry timestamps, while explicit cache purges bypass TTL-based expiration entirely.

Time-Series Databases & Performance

Time-series databases (InfluxDB, TimescaleDB, Prometheus) use Unix timestamps as their primary index because integer comparison is blazingly fast. Binary search on sorted timestamps makes range queries efficient across billions of rows.

Cryptographic Signatures & Replay Attack Prevention

API authentication protocols like AWS Signature V4 include Unix timestamps in their HMAC signatures. Servers reject requests older than a few minutes (typically 300 seconds), creating time-bound signatures that prevent replay attacks. Many OAuth-based systems similarly use timestamp-based expirations to ensure tokens can’t be reused indefinitely.

The Year 2038 Problem

There’s an interesting challenge ahead: On January 19, 2038, at 03:14:07 UTC, 32-bit signed integers (max value: 2,147,483,647) will overflow, wrapping to -2,147,483,648 which represents December 13, 1901. Legacy systems using time_t as 32-bit signed will experience catastrophic failures like expired certificates, broken scheduler logic, and corrupted timestamps.

The solution is transitioning to 64-bit integers, which can represent dates until the year 292 billion—well beyond any practical concern!

Converting Unix Time

Most programming languages have built-in functions to work with Unix time:

JavaScript:

// Get current Unix time
const now = Math.floor(Date.now() / 1000);
// Convert Unix time to date
const date = new Date(1737849600 * 1000);

Python:

import time
from datetime import datetime
# Get current Unix time
now = int(time.time())
# Convert Unix time to date
date = datetime.utcfromtimestamp(1737849600)

Conclusion

Unix time is one of those fundamental concepts that quietly powers much of our digital world. From the timestamps on your social media posts to the expiration of cookies in your browser, Unix time is working behind the scenes to keep everything synchronized.