Handle System: The Infrastructure for Persistent Digital Identifiers
In the vast landscape of the internet, resources frequently move, servers are renamed, and website structures change. This volatility often leads to "link rot," where once-functional links become dead ends. The Handle System solves this problem by providing a proprietary registry that assigns persistent identifiers—known as handles—to information resources. Unlike traditional web addresses, these handles remain constant even when the underlying resource or its location changes.
Developed by Bob Kahn at the Corporation for National Research Initiatives (CNRI) as part of the Digital Object Architecture (DOA), the system was originally funded by DARPA between 1992 and 1996. It emerged alongside the early World Wide Web with a similar goal: creating a reliable framework for accessing distributed digital services.
[ไม่มีภาพประกอบ]
Key Facts
- Purpose: Assigns opaque, persistent identifiers to digital resources to prevent link rot.
- Governance: Administered by the DONA Foundation, which accredits Multi-Primary Administrators (MPAs) like CNRI and the International DOI Foundation.
- Scale: Supports over 12,000 prefixes and processes over 200 million resolution requests per month.
- Major Implementations: Provides the underlying infrastructure for Digital Object Identifiers (DOI) and DSpace.
- Technical Basis: Defined by IETF informational RFCs 3650, 3651, and 3652.
How the Handle System Works
The Anatomy of a Handle
A handle is an opaque identifier, meaning it contains no information about the resource itself. Instead, it acts as a key to retrieve metadata. A handle consists of two parts: a prefix (identifying the naming authority) and a suffix (the local name of the resource).
For example, in the handle 20.1000/100, 20.1000 is the prefix assigned to the naming authority, and 100 is the unique local name. Prefixes can be hierarchical; for instance, 20 is the prefix for CNRI, while 1000 designates a subordinate authority within that prefix.
Handle vs. URL
The primary difference between a handle and a Uniform Resource Locator (URL) is how they store information. A URL encodes the protocol, host name, and file path directly into the string. If any of these change, the URL breaks. In contrast, a handle is bound to metadata. This metadata contains the current location and access details of the resource. When a resource moves, only the metadata needs to be updated; the handle itself remains unchanged.
The Resolution Process
The process of turning a handle into a usable resource is called resolution. This is handled by a Resolver server. The typical workflow is as follows:
- A client sends a handle query to the Global Handle Registry (GHR).
- The GHR identifies the correct Local Handle Service (LHS) and sends the location information back to the client.
- The client queries the LHS, which returns the necessary information (such as a URL) to access the resource.
- The client is then redirected to the final destination.
Implementation and Design Principles
System Architecture
The system is designed for high reliability and scalability. It utilizes a distributed environment where Local Handle Services store specific handles, while the Global Handle Registry manages the prefixes. To ensure persistence, the system follows strict design principles: identifiers must be unique and independent of changeable attributes (like ownership or location), and the resolution mechanism must be redundant to avoid single points of failure.
Technical Compatibility
While the Handle System is compatible with the Domain Name System (DNS), it does not require it. Handles can be expressed as Uniform Resource Identifiers (URIs) using the info: scheme (e.g., info:hdl/20.1000/100) or accessed via HTTP proxy servers, such as https://hdl.handle.net/ or https://doi.org/.
| Feature | Handle System | Standard URL |
|---|---|---|
| Nature | Opaque (no embedded location) | Transparent (contains location) |
| Persistence | High (resistant to link rot) | Low (breaks if resource moves) |
| Resolution | Via Resolver and Metadata | Direct routing to server |
| Management | Distributed Naming Authorities | DNS-based domain ownership |
Applications and Global Use
The Handle System is widely adopted by universities, libraries, government agencies, and commercial enterprises across 71 countries. It is primarily used to identify scholarly journal articles, technical reports, books, theses, and government documents. Because handles can resolve to multiple pieces of information, they can be used to direct users to different versions of the same content, such as a free version versus a paid version, or mirror sites for redundancy.
CNRI provides the source code for reference implementations under a royalty-free public license, allowing the technology to be embedded in other software. This open approach has led to the creation of thousands of handle services worldwide.
Frequently Asked Questions
What is the difference between a Handle and a DOI?
A Digital Object Identifier (DOI) is a specific application of the Handle System. While the Handle System provides the underlying technical infrastructure, DOI is a naming authority that uses that infrastructure to provide persistent identifiers for scholarly and professional documents.
How does the Handle System prevent link rot?
It separates the identifier from the location. Because the handle points to metadata rather than a direct physical address, administrators can update the location in the metadata without changing the handle that users and citations rely on.
Who manages the Global Handle Registry?
The DONA Foundation administers the Global Handle Registry and accredits Multi-Primary Administrators (MPAs), which include organizations like CNRI and the International DOI Foundation.
Is the Handle System open source?
CNRI provides specifications and reference implementation source code under a royalty-free public license, which is similar to an open-source license, enabling broad commercial and non-commercial use.
Can handles be used in web browsers?
Yes. While they can be used natively via client libraries, most users access handles through HTTP proxy servers (like hdl.handle.net) that convert the handle into a standard URL redirect in the browser.