The entire internet was once mapped in a single text file
In the early days of the ARPANET, every computer name and numerical address lived in a single text file called HOSTS.TXT. Maintained manually by computer scientist Elizabeth Feinler at the Stanford Research Institute, network administrators had to download this master file to connect to other machines. As thousands of computers joined the network, the central file became unmanageable. In 1983, Paul Mockapetris invented the Domain Name System, replacing the static list with automated, distributed lookups.
The Master Directory of the Early Network
In the early years of the ARPANET, connecting to another computer required knowing its specific numerical network address. Because strings of numbers are difficult for human operators to memorize and transcribe without error, network engineers adopted alphabetical host names as convenient identifiers. To make this system work, every computer on the network required a reliable way to translate human-friendly names into the underlying numerical addresses used by routing protocols. The original solution was completely centralized: a single plain text file named HOSTS.TXT.
This master file was curated at the Stanford Research Institute's Network Information Center, led by computer scientist Elizabeth Feinler. Whenever an institution added a new computer to the ARPANET, altered an address, or changed a machine's nickname, the administrators had to contact the Network Information Center to request an update. Feinler's team manually validated the changes, updated the central document, and made the new version available on a central server. System administrators across the United States then connected via File Transfer Protocol to download the revised text file and replace their local copies.
The Breaking Point of a Centralized Ledger
A centralized text file functioned adequately when the ARPANET linked only a few dozen academic, government, and military institutions. However, the system possessed severe structural limitations that became critical vulnerabilities as the network expanded. First, the namespace was completely flat, meaning that every host name had to be globally unique across the entire network. If two separate laboratories wanted to name a departmental server 'gateway' or 'mail', the central registry had to reject one of them to prevent routing confusion. Managing these name collisions required ongoing human intervention and negotiation.
Traffic congestion presented an even steeper technical barrier. Every machine joining the network multiplied the total number of entries in HOSTS.TXT, swelling the file size. Simultaneously, more machines meant more frequent administrative updates and an exponential increase in automated download requests. Systems across the network were constantly downloading the entire directory simply to learn about small, isolated changes made on the other side of the country. By the early 1980s, network architects recognized that relying on a single central repository for naming would inevitably choke ARPANET bandwidth and collapse under its own operational weight.
Mockapetris and the Concept of Distributed Authority
Recognizing that the manual curation of HOSTS.TXT could not survive the transition to modern internetworking, computer scientist Paul Mockapetris took up the challenge at the University of Southern California's Information Sciences Institute. In 1983, Mockapetris published the foundational designs for a radical alternative: the Domain Name System, formalized in Request for Comments (RFC) documents 882 and 883. Rather than refining the distribution of a single master file, Mockapetris proposed abolishing the centralized list altogether.
The core breakthrough of Mockapetris's design was the division of naming authority across an inverted tree hierarchy. Instead of a single team maintaining every host identity in one place, the new system distributed ownership into distinct administrative units called domains. An organization granted control over a specific domain could independently name its own computers and create subdomains without asking a central registrar for permission. By delegating responsibility down the branches of an administrative tree, Mockapetris eliminated the single administrative bottleneck that had constrained the early network.
The Architecture of the Domain Hierarchy
The Domain Name System operates as a structured, hierarchical database. At the very top of the tree sits the unnamed root domain, traditionally represented by a single dot. Directly below the root are the Top-Level Domains (TLDs), which initially categorized networks by function and geography, including classifications like .com, .edu, .gov, .org, and two-letter country codes. Below the top level sit second-level domains managed by individual organizations, which can be further subdivided into internal subdomains and individual host records.
This structural hierarchy is reflected directly in the hardware that runs the system. Independent authoritative name servers are responsible for specific portions of the naming tree, known as zones. A root name server does not need to know the IP address of an individual workstation inside a remote university campus; it only needs to know the address of the authoritative name server for the appropriate top-level domain. That top-level server, in turn, points queries toward the authoritative servers of the specific organization. By partitioning data into independent zones, the system ensures that changes remain local while remaining globally accessible.
Automated Resolution and the Power of Caching
To look up an address in this distributed system, client computers rely on software components called resolvers. When a user requests a connection to a specific domain name, the local resolver initiates a query sequence on their behalf. If the address is unknown, the resolver contacts a root name server, receives a referral pointing to the appropriate top-level domain servers, follows that referral down to the organization's authoritative server, and finally retrieves the exact numerical address. This step-by-step navigation happens automatically in a fraction of a second.
Crucially, Mockapetris built caching directly into the DNS architecture to prevent authoritative servers from being overwhelmed by repetitive queries. When a resolver receives a response from an authoritative server, it temporarily stores that record in local memory for an interval specified by the record's Time to Live value. If another application requests the same domain lookup moments later, the resolver answers immediately from cache without sending packets across the wider internet. Caching transformed domain resolution from a heavy network burden into an exceptionally lightweight, scalable protocol capable of serving millions of queries per second.
The Lingering Artifact of the Original System
Although DNS has served as the global standard for domain resolution for over four decades, the legacy of HOSTS.TXT never disappeared entirely. Modern operating systems—including Unix, Linux, macOS, and Windows—still include a local plain text file named 'hosts' that operates on the exact conceptual model established in the 1970s. When an operating system attempts to resolve a network name, its local resolver typically inspects this static text file before dispatching a dynamic query to external DNS servers.
Today, developers, network administrators, and security specialists use this local file to manually override global DNS records for software testing, ad-blocking, or local network routing. The presence of this file on modern devices serves as a direct architectural link to the earliest days of networked computing. The transition from Feinler's manually edited master document at SRI to Mockapetris's automated, distributed lookup framework represents one of the pivotal engineering shifts that enabled a small experimental network to expand into the global internet.
Key takeaways
•Before the Domain Name System, the ARPANET relied on a single master text file (HOSTS.TXT), manually curated by Elizabeth Feinler and her team at the Stanford Research Institute.
•The central file became unmanageable due to flat namespace collisions, manual administration bottlenecks, and the network bandwidth consumed by constant, full-file downloads.
•In 1983, Paul Mockapetris invented DNS (RFC 882 and 883), establishing a distributed, hierarchical tree of independent authoritative servers that eliminated central bottlenecks.
•Every modern operating system still contains a local 'hosts' text file, retaining the original lookup mechanism as an override to automated DNS queries.