DateTime difference between 2 timestamps. Granularity from centuries to nanos.

100%

DateTime difference between 2 timestamps. Granularity from centuries to nanos.

✓ Published0🌍 Public

Last edited May 12, 2017

Created on May 12, 2017

This example shows the elapsed time between September 11, 2001, and the current moment, broken down into units from centuries down to nanoseconds. Two approaches are compared: the first uses Java’s `ChronoUnit` enumeration with a tail-recursive function to compute differences across twelve granularities, while the second uses `TimeUnit` conversion and `ZoneOffset` to produce a day-to-second breakdown. The Scala code builds a human-readable string, adjusting unit labels for singular values, and prints both outputs from the `Stopwatch` object.

AI-generated description

Similar vizzes

Loading thumbnail…

Milliseconds since Unix Epoch

This example converts the current date and time into a single integer representing the number of milliseconds elapsed since the Unix epoch (January 1, 1970). It uses the XQuery function `local:milliseconds-since-epoch`, which calculates the duration between the current timestamp and the epoch, then extracts and sums the day, hour, minute, and second components scaled to milliseconds. The code relies on XQuery’s built-in date and duration types and functions, including `fn:current-dateTime()`, `xs:dateTime()`, `xs:duration()`, and `fn:days-from-duration()`. The result is returned as an `xs:integer`, demonstrating a fundamental time-conversion utility.

CCliffordAnderson

54% match

Loading thumbnail…

Gist 6b09d2803971ebce538a0eb91375b9b0

This example shows a utility function for determining whether two timestamp values fall on the same calendar day. It compares both the day-of-year and the year extracted from each timestamp, using the `Calendar` class from the Android or Java standard library. The function converts each `Long` timestamp into a `Calendar` instance via `getInstance()` and `timeInMillis`, then checks the `DAY_OF_YEAR` and `YEAR` fields. The code relies entirely on `Calendar` APIs and does not involve any visualization or external data source.

HHsuHsiaoHsuan

53% match

Loading thumbnail…

This is the result of JODA not being serializable in scala, resorting to utter bullshit, assumes year is 2016.

This visualization charts time-series data using a custom timestamp conversion workaround. The chart maps dates and times to Unix epoch integers through a Scala function that hardcodes the year as 2016, manually calculating day-of-year offsets and time-of-day seconds. The function parses month abbreviations via string indexing, converts day strings to integers, and splits time strings into hours, minutes, and seconds. This approach bypasses JODA datetime serialization limitations, producing numeric x-axis values for plotting. The rendered graphic likely uses a standard plotting library, though the code excerpt only shows the formatter.

BBBischof

52% match

Loading thumbnail…

Stopwatch

A digital stopwatch displays elapsed time in hours, minutes, and seconds, updating every second with a monospace font. The page uses D3.js selection and formatting APIs—specifically `d3.select` and `d3.format`—to update the text content of the body element. A `setInterval` callback increments a counter each second, and the formatted time is rendered as a colon-separated string.

CCurran Kelleher

51% match

Loading thumbnail…

Sample example demonstrating usage of Stopwatch API of Google Guava.

This example shows how to measure elapsed time in a Java program using the Stopwatch API from Google Guava. It creates a started Stopwatch, pauses execution for a random number of milliseconds via `Thread.sleep`, then stops the timer and prints the total duration. The code demonstrates querying elapsed time in nanoseconds, microseconds, and milliseconds using `stopwatch.elapsed(TimeUnit.*)`. The essential API calls are `Stopwatch.createStarted()`, `stopwatch.stop()`, and `stopwatch.elapsed()`, with the output displayed through standard `System.out.println` statements.

PP7h

51% match

Loading thumbnail…

All the parts we use to convert dates on the page to local times

This example shows a set of JavaScript functions that convert date and time displays on a webpage into a user’s local timezone, and also classifies the age of each timestamp relative to the current moment. The code uses the jQuery library to select and modify DOM elements, calling methods like `$.parseUTCDate` and `$.edate.timeAgoInWords` to handle date parsing and formatting. It assigns CSS classes such as `age-new` or `age-fresh` based on the computed time difference, and updates the text content of each timestamp span accordingly. The data source is the timestamp text within the page’s HTML elements, processed entirely client-side.

CCaged

48% match

Loading thumbnail…

Countdown

This visualization displays a real-time countdown to 9 AM the following day, rendered as large monospaced text in the center of the page. The code uses d3.time.format to produce a timestamp string, d3.time.day and d3.time.day.offset to compute the deadline, and d3.time.second to calculate the remaining time. A recursive tick function updates the text every second using setTimeout, refreshing the display with the current difference between the deadline and the present moment.

Mmbostock

48% match

Loading thumbnail…

Subsecond Ticks

A line chart plots value against time with subsecond precision, using a time scale for the x-axis and a linear scale for the y-axis. The bottom axis displays ticks at fractional seconds, demonstrating correct behavior for millisecond-level time domains. Built with D3 v3, the example uses `d3.svg.axis` for tick generation, `d3.svg.line` for the path, and `d3.time.scale` for mapping dates. Data is loaded from a tab-separated file via `d3.tsv`, with timestamps converted from Unix seconds into JavaScript `Date` objects.

Mmbostock

48% match