The Ultimate Authoritative Guide: Can UUIDs Be Predictable or Guessable? A Deep Dive with uuid-gen

As a seasoned Cloud Solutions Architect, the concept of unique identifiers is fundamental to the design and operation of scalable, secure, and robust distributed systems. Among the most widely adopted solutions for generating unique identifiers are Universally Unique Identifiers (UUIDs), also known as Globally Unique Identifiers (GUIDs). While their primary purpose is to ensure uniqueness across space and time, a critical question arises: can UUIDs be predictable or guessable? This comprehensive guide will dissect this question, explore the underlying principles, analyze different UUID versions, demonstrate practical applications using the powerful uuid-gen tool, and discuss their implications for global industry standards and future architectures.

Executive Summary

Universally Unique Identifiers (UUIDs) are designed to be statistically unique, not cryptographically secure secrets. While most UUID versions, particularly UUIDv1 and UUIDv4, are engineered for high randomness or time-based uniqueness, certain configurations or implementations can inadvertently introduce predictability or guessability. Specifically:

UUIDv1 (Time-based): Incorporates a timestamp and MAC address, which can be predictable if the timestamp is known or the MAC address is discoverable.
UUIDv4 (Random): Relies heavily on a high-quality random number generator. If the RNG is weak, predictable, or seeded with insufficient entropy, UUIDv4s can become guessable.
UUIDv6 and UUIDv7 (Chronological): Introduced to improve sortability by placing a timestamp at the beginning, making them more predictable by design for temporal ordering but not necessarily guessable in terms of predicting a specific future UUID.

The uuid-gen tool, a versatile command-line utility for generating UUIDs, can be configured to produce various UUID versions. Understanding its options and the underlying UUID generation algorithms is crucial for assessing the predictability and guessability of the UUIDs it produces. This guide will empower architects and developers to make informed decisions about UUID generation strategies to maintain the integrity and security of their systems.

Deep Technical Analysis: Understanding UUID Predictability and Guessability

The core of the predictability question lies in the algorithm used to generate a UUID. The standard, RFC 4122, defines several versions, each with distinct generation mechanisms:

UUID Version 1: Time-Based and MAC Address-Based

UUIDv1 is generated using a combination of the current timestamp and the MAC address of the network interface card (NIC) of the machine generating the UUID. The structure is as follows:

Timestamp: A 60-bit timestamp, representing the number of 100-nanosecond intervals since the Gregorian epoch (October 15, 1582).
Clock Sequence: A 14-bit value that helps to avoid duplicates if the clock is reset.
Node Identifier: A 48-bit value, typically the MAC address of the generating node.

Predictability of UUIDv1:

Timestamp: The timestamp component is inherently sequential. If an attacker knows the approximate time of generation, they can narrow down the possible range of UUIDs. For instance, if they know a UUID was generated within a specific hour, they can calculate the corresponding timestamp range and generate potential UUIDs.
MAC Address: The MAC address is a physical identifier. While not always easily obtainable, in many network environments, MAC addresses can be sniffed or discovered. If the MAC address is known, it further reduces the search space for potential UUIDs.
Clock Sequence: The clock sequence is intended to mitigate duplicate generation during clock adjustments. While less predictable than the timestamp or MAC address, it can still be brute-forced within its 14-bit range.

Guessability of UUIDv1: While not strictly "guessable" in the sense of predicting a random sequence, the predictable components make it possible to generate valid UUIDv1s if the timestamp and MAC address are known or can be reasonably inferred. This is a significant concern in security-sensitive applications where UUIDs might be used as part of a security token or identifier that should not be easily reproducible.

Example Representation: 123e4567-e89b-12d3-a456-426614174000 (The first part is the timestamp, the third group contains the clock sequence, and the last group contains the node identifier). The version is indicated by the fourth hexadecimal digit of the third group (here, `1`).

UUID Version 4: Randomly Generated

UUIDv4 is generated using a source of randomness. RFC 4122 specifies that it should be generated from a truly random or pseudo-random number generator. The structure is as follows:

Random Bits: The majority of the UUID consists of randomly generated bits.
Version Bits: Four bits indicating the UUID version (always `0100` for v4).
Variant Bits: Two bits indicating the UUID variant (typically `10` for RFC 4122 compliant UUIDs).

Predictability and Guessability of UUIDv4:

Random Number Generator (RNG): The security of UUIDv4 hinges entirely on the quality of the RNG.
- Cryptographically Secure Pseudo-Random Number Generators (CSPRNGs): Systems like /dev/urandom on Linux or the crypto module in Node.js provide high-quality randomness derived from system entropy. UUIDs generated using these sources are statistically indistinguishable from truly random numbers and are considered practically unguessable.
- Weak or Predictable RNGs: If a UUID generator relies on a weak RNG (e.g., a simple linear congruential generator with a fixed seed) or a predictable source of entropy, then the UUIDs generated can become predictable. An attacker who can determine the seed or the state of the RNG could potentially generate the same UUIDs or predict future ones.
Entropy: The amount of randomness (entropy) available to the RNG is critical. If the system has low entropy, the RNG might produce repetitive or predictable sequences.

Example Representation: f81d4fae-7dec-11d0-a765-00a0c91e6bf6 (The version is `4`).

UUID Version 7: Chronological, Randomly Generated (with Timestamp)

UUIDv7 is a more recent specification designed to address the sortability issues of UUIDv4 while retaining high randomness. It includes a Unix timestamp at the beginning, followed by random bits.

Unix Timestamp (MS): A 48-bit Unix timestamp in milliseconds.
Random Bits: A significant portion of random bits to ensure uniqueness.

Predictability of UUIDv7:

Timestamp: Similar to UUIDv1, the timestamp component makes UUIDv7 chronologically sortable. This means that UUIDs generated closer in time will have lexicographically similar prefixes. This is a design feature for performance reasons (e.g., better indexing in databases) but inherently introduces a degree of predictability regarding temporal ordering.
Randomness: The remaining bits are randomly generated, aiming for the same level of unguessability as UUIDv4, provided a strong RNG is used.

Guessability of UUIDv7: While the timestamp part is predictable for ordering, guessing a *specific* future UUIDv7 is still highly improbable if the random components are sufficiently random. However, an attacker might be able to infer temporal relationships or generate UUIDs within a certain time window.

Example Representation: 017c1b7a-0b2e-711a-93c7-525400123456 (The first part is the timestamp, the version is `7`).

The Role of the `uuid-gen` Tool

The uuid-gen tool is a powerful utility that can generate UUIDs of various versions. Its implementation details directly impact the predictability of the generated UUIDs. When using uuid-gen, it's crucial to understand which version it defaults to or which version you explicitly request.

Default Behavior: Many implementations of uuid-gen default to UUIDv4 for its strong randomness.
Version Selection: A well-designed uuid-gen will allow explicit selection of UUID versions (e.g., uuid-gen -v 1, uuid-gen -v 4, uuid-gen -v 7).
RNG Quality: The underlying operating system's RNG quality is paramount for UUIDv4 and the random components of other versions. uuid-gen typically leverages the system's native randomness sources.

Therefore, to answer the question definitively:

UUIDs *can* be predictable if:
- Version 1 is used, and the timestamp or MAC address is inferable.
- Version 4 or 7 is used, but the underlying random number generator is weak, has insufficient entropy, or is seeded predictably.
UUIDs are generally *not* guessable if:
- Version 4 or 7 is used, and a cryptographically secure random number generator (CSPRNG) with sufficient entropy is employed.

The key is to understand the generation algorithm of the specific UUID version and the quality of the random number generator used by the tool or library generating the UUID.

Practical Scenarios: When Predictability Matters

As a Cloud Solutions Architect, understanding the potential for UUID predictability is not just an academic exercise; it has direct implications for system design, security, and performance. Here are five practical scenarios where this knowledge is crucial:

Scenario 1: API Security and Rate Limiting

Problem: Using predictable UUIDs as primary keys for API requests or as tokens for authentication/authorization can expose systems to attacks. If an attacker can predict a valid UUID, they might be able to:

Bypass authorization: Guessing a user's identifier or a resource's identifier.
Perform denial-of-service (DoS) attacks: Flooding the system with requests using predicted identifiers, overwhelming resources.
Circumvent rate limiting: If rate limits are based on predictable identifiers, an attacker could generate many valid-looking IDs to bypass limits.

Solution: For API endpoints that require strong security and where identifiers should not be guessable, **UUIDv4** generated with a CSPRNG is the preferred choice. Avoid UUIDv1 due to its predictable timestamp and MAC address components. If chronological ordering is beneficial for logging or auditing APIs, consider UUIDv7 but be aware of its temporal predictability. Tools like uuid-gen -v 4 are essential here.

Example using uuid-gen:


# Generate a secure, random UUIDv4 for an API resource identifier
uuid-gen -v 4
# Output: 123e4567-e89b-12d3-a456-426614174000 (example, actual output will be random)

Scenario 2: Database Indexing and Performance

Problem: Traditional UUIDv4, being purely random, can lead to index fragmentation and performance degradation in relational databases. The random nature means that new entries are scattered across the index B-tree, leading to more page splits and slower writes. In contrast, sequential identifiers (like auto-incrementing integers) are ideal for indexing.

Solution: UUIDv1 and, more importantly, the newer **UUIDv6 and UUIDv7** are designed with chronological ordering in mind. By placing a timestamp at the beginning of the UUID, they offer a compromise between uniqueness and sortability. This allows databases to insert new records more contiguously, leading to better index locality and improved write performance. UUIDv7 is particularly well-suited for modern databases that can handle its format.

Example using uuid-gen (hypothetical for v6/v7 if supported):


# Generate a chronologically sortable UUIDv7 for database primary keys
uuid-gen -v 7
# Output: 017c1b7a-0b2e-711a-93c7-525400123456 (example, timestamp will reflect current time)

Note: While UUIDv1 has a timestamp, its MAC address component can still pose privacy and security risks. UUIDv7 offers a more robust solution for this use case.

Scenario 3: Distributed System Coordination and Locking

Problem: In distributed systems, generating unique identifiers for locks, leader election tokens, or distributed transactions is critical. If these identifiers are predictable, multiple nodes might generate the same identifier concurrently, leading to race conditions and system instability. For instance, if a lock ID is based on predictable information, two nodes might try to acquire the same lock simultaneously.

Solution: **UUIDv4** is the ideal choice for such scenarios. Its reliance on a strong RNG ensures a vanishingly small probability of collision and makes it practically impossible for different nodes to predict the same identifier. The uuid-gen tool, by defaulting to or being configured for UUIDv4, provides the necessary randomness.

Example using uuid-gen:


# Generate a unique identifier for a distributed lock
uuid-gen -v 4
# Output: a1b2c3d4-e5f6-4789-a1b2-c3d4e5f6a7b8 (example)

Scenario 4: IoT Device Identification and Data Streams

Problem: The Internet of Things (IoT) involves a vast number of devices generating data. Unique identification for each device and its data streams is essential for tracking, management, and analytics. If device IDs are predictable, it could lead to spoofing or confusion in data streams.

Solution:

Device IDs: For long-term, stable identifiers, a **UUIDv1** could be considered if the MAC address is considered sufficiently unique and privacy concerns are managed (e.g., in a private network). However, **UUIDv4** offers better security and randomness, making it a safer choice, especially for devices communicating over public networks.
Data Stream Identifiers: For ephemeral data streams or event identifiers, **UUIDv4** is paramount to prevent collisions and ensure each event is distinctly identifiable. For time-series data, **UUIDv7** can offer advantages in storage and querying efficiency due to its chronological nature.

Example using uuid-gen:


# Generate a unique identifier for a new IoT device
uuid-gen -v 4

# Generate a unique identifier for a specific data reading from an IoT device
uuid-gen -v 7 # for chronological ordering of readings

Scenario 5: Blockchain and Cryptographic Applications

Problem: In blockchain technology and other cryptographic applications, identifiers are often used as transaction IDs, block hashes (though typically derived from block content), or unique references to on-chain assets. Predictability or guessability in these contexts can be catastrophic, leading to replay attacks, double-spending, or compromised integrity.

Solution: **UUIDv4** is the only acceptable choice for generating identifiers that require cryptographic security and unpredictability. The random bits ensure that no attacker can guess or manipulate these identifiers. Applications in this domain must use the most robust CSPRNG available on the platform. The uuid-gen tool, when configured for v4 and running on a system with good entropy, is a suitable tool.

Example using uuid-gen:


# Generate a unique, unpredictable transaction ID for a blockchain
uuid-gen -v 4
# Output: 98765432-10fe-4edc-ba98-76543210fedc (example)

Global Industry Standards and RFC Compliance

Universally Unique Identifiers are governed by several standards, most notably **RFC 4122** ("A Universally Unique Identifier (UUID)"). This RFC defines the structure and generation algorithms for different UUID versions. Understanding these standards is crucial for interoperability and ensuring that generated UUIDs behave as expected.

RFC 4122 Versions Overview

RFC 4122 defines the following UUID versions:

Version	Description	Generation Method	Predictability Concern	Use Case Suitability
1	Time-based	Timestamp + MAC Address	High (timestamp and MAC address are sequential/identifiable)	Discouraged for security-sensitive applications; acceptable for non-critical, internal identifiers where MAC address is not a privacy concern.
2	DCE Security	Reserved, not widely implemented or defined.	N/A	N/A
3	Name-based (MD5)	MD5 hash of a namespace identifier and a name.	Predictable if namespace and name are known.	Generating IDs from names/URIs.
4	Randomly Generated	Randomness from a CSPRNG.	Low (if CSPRNG is strong and has sufficient entropy). High if RNG is weak.	General-purpose, security-sensitive applications, distributed systems.
5	Name-based (SHA-1)	SHA-1 hash of a namespace identifier and a name.	Predictable if namespace and name are known.	Generating IDs from names/URIs (preferred over v3 due to SHA-1).
6	Reordered Time-based	Timestamp + Clock Sequence + Node (reordered for sortability)	Moderate (timestamp component is predictable for ordering).	Databases, logs where chronological sortability is beneficial.
7	Chronological, Random	Timestamp (ms) + Randomness	Moderate (timestamp component is predictable for ordering). Randomness relies on RNG.	Databases, logs, general use cases requiring sortability without MAC address concerns.
8	Custom	Defined by the implementer.	Varies widely.	Specific application needs.
9	Custom	Defined by the implementer.	Varies widely.	Specific application needs.
10	Custom	Defined by the implementer.	Varies widely.	Specific application needs.
11	Custom	Defined by the implementer.	Varies widely.	Specific application needs.

The `uuid-gen` Tool and Standards Compliance

A well-implemented uuid-gen tool adheres to these RFC standards. When you specify a version (e.g., uuid-gen -v 4), it should generate a UUID conforming to the bit patterns and structure defined for that version. The critical differentiator for predictability and guessability, especially for UUIDv4, is the quality of the underlying random number generator used by the tool. Most modern operating systems provide access to CSPRNGs that uuid-gen can leverage.

Implications for Different Industries

Web Development: Primarily uses UUIDv4 for primary keys, session IDs, and API identifiers where security and uniqueness are paramount. UUIDv7 is gaining traction for database indexing.
Databases: UUIDv1 was historically used, but issues with MAC address privacy and predictability led to a shift towards UUIDv4. Now, UUIDv6 and UUIDv7 are becoming the preferred choice for database primary keys due to their sortability, improving performance.
Distributed Systems: UUIDv4 is the de facto standard for generating unique identifiers for locks, messages, and distributed transaction IDs due to its randomness.
IoT: A mix of UUIDv4 for general uniqueness and security, and potentially UUIDv7 for time-series data streams.
Security and Cryptography: Strictly UUIDv4 generated from the highest quality CSPRNGs available.

Multi-language Code Vault: Implementing UUID Generation

While uuid-gen is excellent for command-line use, programmatic generation is often required. Here's how you can generate UUIDs in various popular programming languages, emphasizing best practices for avoiding predictability.

Python

Python's `uuid` module is robust and leverages the system's CSPRNG for UUIDv4.


import uuid

# Generate UUIDv1 (Time-based)
uuid_v1 = uuid.uuid1()
print(f"UUIDv1: {uuid_v1}")

# Generate UUIDv4 (Random) - Recommended for security
# Uses system's os.urandom() which is a CSPRNG
uuid_v4 = uuid.uuid4()
print(f"UUIDv4: {uuid_v4}")

# Generate UUIDv7 (Chronological, Random) - Requires a third-party library
# Example using 'uuid7' library: pip install uuid7
try:
    import uuid7
    uuid_v7 = uuid7.uuid7()
    print(f"UUIDv7: {uuid_v7}")
except ImportError:
    print("UUIDv7 library not installed. Install with: pip install uuid7")

JavaScript (Node.js)

Node.js's built-in `crypto` module or the popular `uuid` package (which uses `crypto`) are excellent for generating secure UUIDs.


// Using the 'uuid' package: npm install uuid
const { v1, v4, v7 } = require('uuid');

// Generate UUIDv1 (Time-based)
const uuid_v1 = v1();
console.log(`UUIDv1: ${uuid_v1}`);

// Generate UUIDv4 (Random) - Recommended for security
// Uses Node.js's crypto.randomUUID() or fallback to crypto.getRandomValues()
const uuid_v4 = v4();
console.log(`UUIDv4: ${uuid_v4}`);

// Generate UUIDv7 (Chronological, Random) - Available in newer versions of 'uuid' or via specific implementations
// Note: Native crypto.randomUUID() supports v7 in recent Node.js versions (e.g., v19+)
// If using older Node.js or 'uuid' package, you might need a specific v7 implementation.
try {
    const uuid_v7 = v7(); // Assumes v7 support in the 'uuid' package or Node.js
    console.log(`UUIDv7: ${uuid_v7}`);
} catch (e) {
    console.error("UUIDv7 generation might require specific Node.js version or library.", e);
}

// Direct use of Node.js crypto API (more explicit)
const crypto = require('crypto');
console.log(`Node.js crypto UUIDv4: ${crypto.randomUUID()}`);
// Node.js crypto.randomUUID() supports v7 natively in recent versions.
// console.log(`Node.js crypto UUIDv7: ${crypto.randomUUID({ version: 7 })}`); // Example syntax, check Node.js docs for exact usage

Java

Java's `java.util.UUID` class provides methods for generating UUIDs.


import java.util.UUID;

public class UUIDGenerator {
    public static void main(String[] args) {
        // Generate UUIDv1 (Time-based)
        UUID uuid_v1 = UUID.randomUUID(); // Note: Java's UUID.randomUUID() actually implements v1
        System.out.println("UUIDv1 (Java): " + uuid_v1.toString());

        // For UUIDv4 (Random), you'd typically use a library or specific implementation.
        // Java's standard UUID.randomUUID() is often based on v1.
        // For true v4, consider external libraries like Apache Commons or specific CSPRNG usage.
        // Example using a conceptual approach for v4 if not directly supported by standard lib.
        // Many libraries abstract this, e.g., `com.fasterxml.uuid.Generators.randomBasedGenerator()`.

        // For UUIDv7, external libraries are generally required.
        // Example conceptually using a hypothetical library:
        // UUID uuid_v7 = UUID7Generator.generate();
        // System.out.println("UUIDv7 (Conceptual): " + uuid_v7.toString());
    }
}

Note for Java: Java's `java.util.UUID.randomUUID()` method *actually* generates a UUIDv1, despite its name. For true UUIDv4 generation in Java, you'll typically need to use external libraries (e.g., `com.fasterxml.uuid` from FasterXML) or implement it yourself using `java.security.SecureRandom` and carefully constructing the bits according to RFC 4122.

Go

Go's standard library includes a `github.com/google/uuid` package (though often imported as `uuid` or `gofrs/uuid`).


package main

import (
	"fmt"
	"log"

	"github.com/google/uuid" // or "github.com/gofrs/uuid"
)

func main() {
	// Generate UUIDv1 (Time-based)
	uuid_v1, err := uuid.NewUUID()
	if err != nil {
		log.Fatalf("Error generating UUIDv1: %v", err)
	}
	fmt.Printf("UUIDv1: %s\n", uuid_v1.String())

	// Generate UUIDv4 (Random) - Recommended for security
	// Uses crypto/rand for randomness
	uuid_v4, err := uuid.NewRandom()
	if err != nil {
		log.Fatalf("Error generating UUIDv4: %v", err)
	}
	fmt.Printf("UUIDv4: %s\n", uuid_v4.String())

	// Generate UUIDv7 (Chronological, Random) - Requires specific implementation
	// Example using a hypothetical v7 generator or a library that supports it.
	// The standard 'uuid' package might not support v7 directly in older versions.
	// You may need to look for newer libraries or specific implementations.
	// For instance, if a library provides `uuid.NewV7()`:
	/*
	uuid_v7, err := uuid.NewV7() // Hypothetical function
	if err != nil {
		log.Fatalf("Error generating UUIDv7: %v", err)
	}
	fmt.Printf("UUIDv7: %s\n", uuid_v7.String())
	*/
}

Future Outlook: Evolving UUID Standards

The landscape of unique identifiers is not static. As systems become more complex and distributed, the demands on identifiers evolve. The introduction of UUIDv6 and UUIDv7 signifies a move towards identifiers that balance uniqueness with practical considerations like database performance and chronological ordering.

Key Trends:

Chronological Sortability: The demand for sortable UUIDs, especially for database indexing and log analysis, is growing. UUIDv6 and UUIDv7 address this by incorporating timestamps, providing a better alternative to purely random UUIDs in certain contexts.
Enhanced Security: While UUIDv4 is generally secure, the ongoing evolution of cryptography and the increasing sophistication of attackers mean that the reliance on high-quality CSPRNGs will only become more critical.
Standardization and Interoperability: As new UUID versions emerge, ensuring consistent implementation across different platforms and languages is crucial for global interoperability. Tools like uuid-gen play a vital role in demonstrating and adhering to these standards.
Contextual UUIDs: Future standards might explore UUIDs with more context embedded, allowing for more efficient querying or specific application logic, while still maintaining a high degree of uniqueness.
Integration with Other Technologies: We can expect closer integration of UUID generation with distributed ledger technologies, edge computing devices, and advanced data processing pipelines.

The Role of `uuid-gen` in the Future:

uuid-gen will continue to be an invaluable tool for:

Prototyping and Testing: Quickly generating UUIDs of various versions for testing hypotheses and proofs of concept.
Educational Purposes: Demonstrating the differences between UUID versions and their generation mechanisms.
Adoption of New Standards: Providing an accessible way to generate and experiment with newer UUID versions like v6 and v7 as they become more widely adopted.
Ensuring Compliance: Verifying that implementations in code align with the expected output of standard UUID generation.

As Cloud Solutions Architects, staying abreast of these evolving standards and tools is essential for building future-proof, performant, and secure systems. The ability to choose the right UUID version and ensure its correct generation—whether through the command line with uuid-gen or programmatically—is a fundamental skill.

Conclusion

The question of whether UUIDs can be predictable or guessable is nuanced. While **UUIDv4, when generated using a cryptographically secure random number generator with sufficient entropy, is practically unguessable**, other versions and implementations carry inherent predictability:

UUIDv1 is predictable due to its timestamp and MAC address components.
UUIDv7 is predictable in its chronological ordering but not necessarily in predicting a specific future value if its random components are strong.
Any UUID version can become guessable if the underlying random number generator is weak or poorly seeded.

The uuid-gen tool, by allowing the selection of different UUID versions and leveraging system randomness, is a powerful instrument for architects and developers. By understanding the technical underpinnings of each UUID version and the capabilities of tools like uuid-gen, we can make informed decisions to ensure that our identifiers provide the required level of uniqueness, security, and performance for our applications. The journey from simple unique identifiers to sophisticated, context-aware ID generation is ongoing, and embracing these advancements is key to architecting the next generation of cloud solutions.

The Ultimate Authoritative Guide: Can UUIDs Be Predictable or Guessable? A Deep Dive with uuid-gen

Executive Summary

Deep Technical Analysis: Understanding UUID Predictability and Guessability

UUID Version 1: Time-Based and MAC Address-Based

UUID Version 4: Randomly Generated

UUID Version 7: Chronological, Randomly Generated (with Timestamp)

The Role of the uuid-gen Tool

Practical Scenarios: When Predictability Matters

Scenario 1: API Security and Rate Limiting

Scenario 2: Database Indexing and Performance

Scenario 3: Distributed System Coordination and Locking

Scenario 4: IoT Device Identification and Data Streams

Scenario 5: Blockchain and Cryptographic Applications

Global Industry Standards and RFC Compliance

RFC 4122 Versions Overview

The uuid-gen Tool and Standards Compliance

Implications for Different Industries

Multi-language Code Vault: Implementing UUID Generation

Python

JavaScript (Node.js)

Java

Go

Future Outlook: Evolving UUID Standards

Key Trends:

The Role of uuid-gen in the Future:

Conclusion

The Role of the `uuid-gen` Tool

The `uuid-gen` Tool and Standards Compliance

The Role of `uuid-gen` in the Future: