This article outlines key API security mechanisms—including encryption, signing, timestamp validation, AppId authentication, rate limiting, blacklist control, and data validation—and provides practical Java code examples and implementation guidelines for each technique.
Elasticsearch does not store a built‑in write timestamp, so to trace when a document was indexed you must add the field during ingest, using either an Ingest Pipeline, Logstash/Beats configuration, or application‑side code, with guidance on advantages, caveats, and handling historical data.
The article explains why developers are moving from UUID to ULID, detailing ULID’s 128‑bit compatibility, massive per‑millisecond uniqueness, lexicographic sorting, compact 26‑character Base32 encoding, timestamp integration, strong randomness, and practical use cases such as distributed systems and database sharding.
This article explains why MySQL partitions based on a timestamp column still function correctly even when the application does not explicitly set the column, by detailing the default CURRENT_TIMESTAMP behavior, partition key evaluation, and practical examples with table definitions and insert statements.
A Java backend service was unexpectedly showing a three‑day unblocking date instead of two, due to a one‑second overflow when converting LocalDateTime to java.util.Date for a PostgreSQL timestamp column, and the article walks through diagnosis, replication, and two practical fixes.
This article compares MySQL's INT, TIMESTAMP, and DATETIME column types, explaining their limits, default behaviors, timezone handling, performance implications, and best‑practice recommendations for storing temporal data in modern applications.
This article presents a comprehensive guide to designing secure third‑party APIs, covering the generation and management of Access Key/Secret Key pairs, signature creation, timestamp and nonce anti‑replay techniques, token handling, request throttling, IP whitelisting, idempotency, versioning, response standards, and practical code examples in Java and SQL.
A Java backend bug caused blacklist unblocking times to be stored one second later than expected due to mismatched Date and TIMESTAMP precision, daylight‑saving and timezone conversions, and millisecond rounding, which was diagnosed through code review, AI analysis, and batch testing, then fixed by normalising nanoseconds or adjusting database column precision.
This article outlines essential security measures for public APIs—including data encryption, signing, timestamp validation, AppId authentication, rate limiting, blacklist handling, and data validation—explaining why each is needed and providing concrete Java implementation examples such as HTTPS, MD5 signatures, token‑bucket algorithms, and RateLimiter usage.
This article explains why storing dates as strings is inefficient, compares MySQL DATETIME and TIMESTAMP—including timezone handling and performance trade‑offs—shows practical SQL examples, adds PostgreSQL equivalents, and offers concise recommendations for selecting the optimal time storage format.
This tutorial explains how to use PHP's time(), date(), strtotime(), and date_default_timezone_set() functions to retrieve the current timestamp, format dates, perform date arithmetic, and configure timezones, providing practical code examples for each operation.
A developer discovers a bug where a time component displays incorrect dates because the backend switched timestamp values from numbers to strings, and learns how to correctly parse timestamps in JavaScript using Dayjs and defensive Number conversion.
This article explains why storing dates as strings is inefficient, compares MySQL DATETIME and TIMESTAMP—including storage size, range, timezone handling, and performance—and discusses when to use numeric Unix timestamps or PostgreSQL equivalents for reliable time data management.
When storing dates in MySQL or PostgreSQL, avoid VARCHAR fields and select between DATETIME (no time‑zone, larger range) and TIMESTAMP (UTC conversion, smaller range) based on whether automatic time‑zone handling and the 2038 limit suit your application, with Unix timestamps as a high‑performance alternative.
This article explains why storing dates as strings is problematic, compares MySQL's DATETIME and TIMESTAMP types—including their storage size, range, and timezone behavior—provides practical SQL examples, discusses numeric Unix timestamps, and offers guidance on selecting the most suitable type for different scenarios.
This guide details a secure third‑party API design, covering API key generation, request signing with timestamps and nonces, permission division, CRUD endpoint definitions, unified response structures, and best‑practice security measures such as HTTPS, IP whitelisting, rate limiting, logging, and idempotency handling.
This article explains GMT, UTC, time zones, local time, and daylight‑saving time, outlines their effects on game server and client logic, presents three common handling strategies, lists typical bugs, and provides a detailed testing checklist for reliable time‑related features.
Hotlinking attacks steal popular media by fetching resources from major platforms, but developers can protect assets using anti-leech methods such as Nginx referer checks, SpringBoot filters, token validation, timestamp verification, and graphical captchas, each with strengths and limitations against forged requests.
This article presents a comprehensive design scheme for third‑party API interfaces, covering access‑key/secret‑key generation, permission segmentation, signature flow and rules, anti‑replay mechanisms, token handling, and concrete Java code examples for secure request validation.
This article explains the structure and generation of RTP timestamps for audio and video, the role of NTP timestamps as a common time base, how RTP and NTP are correlated through Sender Reports and linear regression, and the calculations used to achieve accurate audio‑video synchronization and target delay management in WebRTC.
This article explores several strategies—timestamp with random numbers, MD5 hashing, UUIDs, and an optimized Base62 conversion combined with Redis‑based locking—to generate short, globally unique CDN file names for an OSS upload platform.
This article explains the PHP filectime() function, how it returns a file's creation timestamp, and provides a complete example showing file existence checking, timestamp conversion with date(), and output handling, while also mentioning related functions such as filemtime() and fileatime() for broader file time management.
This article analyzes how MySQL binlog records timestamps and exec_time for GTID, BEGIN, Table_map, Write, and Xid events on both master and slave, explains the calculation of original_commit_timestamp and immediate_commit_timestamp, and provides formulas and source‑code references to help diagnose replication delay.
The article presents a comprehensive guide to designing secure third‑party APIs, covering access‑key/secret‑key generation, token management, signature algorithms, timestamp and nonce anti‑replay mechanisms, permission granularity, request logging, rate limiting, and example Java and SQL implementations.
This article explains the meaning, generation process, and operational impact of the new immediate_commit_timestamp and original_commit_timestamp fields in MySQL 8.0 binlog events, including how they affect replication delay calculations, warning handling, and precise monitoring of transaction commit times.
This article explains how to protect microservice APIs from tampering and replay attacks by using HTTPS, request signing, nonce‑timestamp mechanisms, and AppId/AppSecret authentication, and demonstrates a complete Java/Spring implementation with a responsibility‑chain based verification filter.
This article explains how to use PHP's timestamp functions—including time(), strtotime(), date(), and mktime()—to obtain current timestamps, convert strings to timestamps, format dates, handle time zones, and perform relative time calculations with practical code examples.
This article explains the PHP date() function, covering its syntax, required and optional parameters, common format characters for year, month, day, hour, minute and second, additional textual options, usage for timestamp conversion, and timezone considerations, helping developers handle date and time tasks efficiently.
The article recounts how Ken Thompson and Dennis Ritchie invented the Unix epoch as a single integer counting seconds since 1970, explains its advantages, exposes the 32‑bit overflow issue known as the Y2K38 problem, and outlines the transition to 64‑bit timestamps in modern systems.
This article recounts how Ken Thompson and Dennis Ritchie devised the Unix Epoch Time as a simple integer timestamp, explains its advantages, the 32‑bit limitation leading to the Y2K38 issue, and describes the transition to 64‑bit timestamps in modern systems.
This article explains why Redis experiences key‑setting race conditions under high concurrency and presents two practical solutions—using a distributed lock with timestamps and serializing writes via a message queue—to ensure correct ordering and data consistency.
This article outlines essential API security mechanisms—including encryption, signing, timestamp validation, AppId authentication, rate limiting, blacklist handling, and data validation—and provides practical Java implementation examples for each technique.
This guide explains how attackers can use Linux shell commands such as touch, stat, and ls, combined with custom Bash scripts, to record, modify, and restore file timestamps, enabling them to conceal evidence of intrusion and automate timestamp manipulation on compromised servers.
This article introduces several SQL date‑time functions—including TO_TIMESTAMP, LOCALTIMESTAMP, NOW, CURRENT_TIMESTAMP, DATE_FORMAT, and UNIX_TIMESTAMP—explaining their syntax, parameters, behavior, and providing example queries with expected results for each function.
This article evaluates how MySQL stores time using datetime, timestamp, and bigint fields by inserting 500,000 records and measuring query, grouping, and sorting speeds, concluding that bigint generally offers the best performance for time‑range operations while timestamp saves space when no manipulation is needed.
This article explains ULID—a lexicographically sortable, 128‑bit identifier combining timestamp and randomness—detailing its advantages over UUID, specifications, binary layout, common use cases, and provides Python code examples for generating and manipulating ULIDs.
This article explains how MySQL determines default values for TIMESTAMP columns, the effect of the explicit_defaults_for_timestamp parameter, when zero‑date values are permitted via sql_mode, and demonstrates the behavior through four test scenarios with corresponding SQL statements and results.
This article explains why timestamps in MySQL binary logs can appear out of order, detailing how event times are derived from the thread start time, how long‑running transactions and binlog rotation affect ordering, and provides code examples and an experiment to illustrate the behavior.
This guide explains how attackers can conceal their activities on a Linux system by manipulating file timestamps using the touch, stat, and ls commands and by automating the process with a Bash script that saves, restores, and reapplies timestamps to hide evidence of compromise.
This article explores several Python techniques—including the time, datetime, and dateutil modules, as well as pure arithmetic and NumPy—to reliably transform a "HH:MM:SS" string into the total number of seconds, while addressing timezone and year‑offset nuances.
This article outlines ten practical methods for protecting API data, covering transmission encryption, digital signatures, token authentication, timestamp and nonce mechanisms, rate limiting, blacklist/whitelist controls, data masking, and parameter validation to ensure comprehensive interface security.
The article examines how naive timestamp caching can increase CPU usage under high concurrency, analyzes implementations in Alibaba’s Cobar and Sentinel, presents performance test results, and explains Sentinel’s adaptive algorithm that switches between cached and direct timestamps based on QPS.
This guide explains how to protect a Spring Cloud Gateway service from packet sniffing by using RSA asymmetric encryption, timestamp validation, unique request IDs stored in Redis, and MD5 signature checks, with complete Java and front‑end code examples.
The article explains replay attacks, describes how using a timestamp, a nonce, or a combination of both can protect API requests, and provides complete PHP code examples for signing and verifying requests to ensure each call is accepted only once.
This tutorial demonstrates how to programmatically embed a graphical seal and a trusted network timestamp electronic signature into a PDF using Java, the Spire library, and a .pfx certificate, covering preparation, signature creation, positioning, timestamp configuration, visual settings, and final saving.
This article provides a detailed tutorial on Python's time‑related classes and functions, covering Unix timestamps, conversion tools, and the practical use of the calendar, time, and datetime modules with examples of formatting, timezone conversion, and common time‑conversion tricks for everyday programming tasks.
This article evaluates how MySQL handles time data stored as datetime, timestamp, and bigint by inserting half a million records and measuring query, grouping, and sorting speeds, concluding that bigint generally offers the best performance for time‑range operations.
The article explains how MySQL's explicit_defaults_for_timestamp setting and strict SQL mode cause TIMESTAMP columns with default CURRENT_TIMESTAMP to produce "Invalid default value" errors during migration from 5.7.28 to 5.7.20, especially when synchronization tools omit NULL and DEFAULT attributes.
This article explains how the MySQL system variable explicit_defaults_for_timestamp controls the default and NULL handling of TIMESTAMP columns, demonstrates the differences between OFF and ON settings with practical tests, and discusses why the parameter is being deprecated for stricter time‑data management.
This article benchmarks MySQL's datetime, timestamp, and bigint columns by inserting 500,000 rows and measuring query, group‑by, and order‑by performance, concluding that bigint generally offers the best speed for time‑based operations while timestamp saves space for static timestamps.
The article explains how to secure API endpoints by combining token authentication, timestamp validation, and cryptographic signatures to prevent data tampering, replay attacks, and denial‑of‑service attempts, while offering guidance on practical trade‑offs.
This article explains MySQL's three time types, highlights the quirks and automatic defaults of TIMESTAMP—including the 2038 problem, high‑concurrency issues, and unexpected behavior in non‑strict mode—provides practical examples, and offers guidance on configuring server variables or switching to DATETIME for safer handling.
This guide explains the three Unix file timestamps, shows how to view them with stat, and demonstrates using the find command’s ‑newerXY option to locate files modified, accessed, or status‑changed after a specific date and time.
This article provides a comprehensive guide to Python's time-related modules—including timestamps, the calendar module, time, and datetime—explaining core concepts, useful functions, and real‑world examples, plus handy conversion techniques for everyday programming tasks.
This guide explains how PHP's date() function formats local timestamps into custom strings, details its optional parameters, return behavior, and provides multiple practical code examples demonstrating common format patterns and timezone handling.
This article explains how to protect API data exchange by using access tokens, timestamps, MD5 signatures, Redis caching, and a custom @NotRepeatSubmit annotation to prevent replay attacks and duplicate submissions in a Spring Boot backend.
This article demonstrates three PHP techniques for obtaining millisecond‑precision timestamps—13‑digit integer, floating‑point value, and a custom 14‑digit format—providing full code examples and usage illustrations. It also shows how to integrate the timestamp into request data structures for payment APIs.
This article explains how timestamp and nonce mechanisms can be combined to protect API endpoints from parameter tampering and replay attacks, illustrating the approach with a Java Spring interceptor that stores nonces in Redis and validates signatures on each request.
This tutorial walks through Python's time and datetime modules, covering timestamps, sleep, local time, formatting, parsing, arithmetic, and the dateutil library for flexible month and year adjustments, with code examples and visual output to illustrate each concept.
The article explores practical approaches for authenticating internal service APIs, comparing plain token usage, IP whitelisting, and salted signature schemes with timestamps, and explains their implementation details, security trade‑offs, and suitability for a B2B cloud‑operated platform.
This article provides a comprehensive overview of Python's three core time modules—datetime, time, and calendar—explaining their design, key concepts like epoch, UTC, DST, and demonstrating essential APIs for retrieving, converting, and manipulating dates and times.
This article walks through practical methods for securing internal API calls—starting with simple token checks, then enhancing security with IP whitelisting, salted signatures, and timestamped requests—while weighing trade‑offs like HTTPS overhead and time synchronization.
This article examines common date and time storage options in databases—string, DateTime, Timestamp, and Unix timestamp—highlighting their characteristics, timezone handling, performance implications, and best-use scenarios, with Java code examples and migration tips.
This article compares common database date‑time storage options—string fields, DATETIME, TIMESTAMP, and Unix timestamps—explaining their formats, range limits, timezone handling, performance implications, and provides Java code examples and SQL conversion tips to help developers select the most suitable approach for their systems.
This article outlines essential API security mechanisms—including encryption, signing, timestamps, AppId authentication, rate limiting, blacklisting, and data validation—and provides practical Java implementation examples and code snippets.
This guide explains how to perform time addition, subtraction, and difference calculations in shell scripts by converting dates to timestamps, manipulating seconds, and converting results back to readable formats, complete with practical examples and essential Bash arithmetic operators.
This article provides a comprehensive overview of Python's time‑related modules—datetime, time, and calendar—explaining their design, key concepts like epoch, UTC, DST, and practical APIs for obtaining, converting, and manipulating dates and times.
This guide explains how to perform time addition and calculate time differences in Bash by converting dates to Unix timestamps, adjusting with arithmetic, and converting results back to readable format, including examples and shell arithmetic operator notes.
This article explains the physical and philosophical notions of time, the challenges of representing time in computing, and provides a comprehensive guide to Java's date‑time APIs—including System.currentTimeMillis, System.nanoTime, java.util.Date, java.sql.Timestamp, Calendar, SimpleDateFormat, and the modern Java 8 classes such as Instant, LocalDate/Time, ZonedDateTime, and DateTimeFormatter—while highlighting common pitfalls and best practices.
The article investigates a MySQL performance issue where timestamp fields trigger high CPU usage due to time‑zone conversion, explains the internal representation of TIMESTAMP, shows stack traces and perf data, and proposes configuration and schema changes to resolve the problem.
This article explains the Redis concurrent key competition problem, illustrates typical scenarios where multiple clients modify the same key, and presents four practical solutions—optimistic locking with WATCH/EXEC, distributed locks, timestamp ordering, and message‑queue serialization—to ensure data correctness under high concurrency.
The article explains a 14‑hour discrepancy between MySQL's created_time and recovery_time timestamps, analyzes JVM and driver timezone settings, traces MyBatis and MySQL driver conversions, and provides practical fixes by adjusting MySQL server and JDBC URL timezones.
A bug was discovered where a user's VIP expiration date could not extend beyond a specific day in 2038 because the timestamp was stored in a signed INT column, whose maximum value (2147483647) corresponds to 2038‑01‑19 11:14:07, causing the system to fail to save later dates.
This article explores common MySQL DATETIME timestamp precision issues caused by mismatched mysql‑connector‑java and server versions, demonstrates three practical solutions, and provides a step‑by‑step case study with code examples to help developers choose the right time field type and avoid timezone pitfalls.
This guide explains how to use the Linux touch command to modify file access and modification timestamps, prevent accidental file creation, set custom dates with various options, and even adjust time zones, providing clear examples and command outputs for each scenario.
This guide explains why accurate date‑time handling matters for tasks like log naming, introduces the common date format specifiers, and provides step‑by‑step shell examples for retrieving the current time, custom‑formatted dates, relative dates such as yesterday or one hour ago, and converting between human‑readable dates and Unix timestamps.
This article explains how attackers can use Linux shell commands and a custom Bash script to record, modify, and later restore file timestamps, thereby concealing evidence of intrusion, with detailed examples of touch, stat, ls, sed, and conditional scripting.
This guide explains that blockchain block creation times are stored as Unix timestamps in seconds, describes the Unix time concept, shows how to convert timestamps in Java from milliseconds to seconds and back, and provides a concrete Ethereum example using Web3.js to fetch a block’s timestamp.
This article explains how MySQL binlog timestamps are derived from the THD start_time, why all events in a transaction share the same timestamp, how exec_time is calculated, and demonstrates the effect of autocommit and manual commit on binlog timing through concrete examples and source code analysis.
Replacing a VARCHAR column that stores timestamp strings with a native TIMESTAMP type in a massive sorting table reduced query time from over 20 minutes to 39 seconds, demonstrating a 30‑plus‑fold speedup due to smaller storage, faster CPU comparisons, and reduced I/O.
The article examines common pitfalls when retrieving a day's orders in MySQL, explains why using BETWEEN can be ambiguous, shows how timestamp precision and appending .999 affect results, and argues for clear, maintainable SQL and test‑code practices.
