What Is a Domain Name

The previous topic established that reaching a server requires an address. Even so, you did not type 192.0.2.10 into the address bar; you typed example.test. The two forms point to the same server, but the difference between them is not only readability.

This lesson examines the name itself: how it is structured, who owns it and why a separate layer sits on top of the address. Translating the name into an address is the next lesson’s subject.

The Reason for Indirection

Separating the name from the address solves two distinct problems.

Memorability is only the first of these, and the less important one. People struggle to remember number sequences; names carry meaning.

The ability to break the link is the real reason. As established in the previous lesson, an address is a statement of location: when an organization moves its server to another provider, the address must change. If the address were used directly, the move would affect every user — the value everyone knew would become invalid.

Once a name layer sits in between, the move reduces to updating a single record. The name stays fixed; the address it points to changes. The user does nothing.

The same indirection works in the other direction too. A single name can point to multiple addresses; requests are distributed among them. A single address can also host multiple names — the subject of this topic’s last lesson. The relationship between name and address is not one-to-one.

This is a pattern that recurs throughout computer science: placing a stable name over a value that can change. It is the same idea as variable binding from the Programming Fundamentals course; the code that refers to the name does not change even when what the name points to does.

The Structure of a Name

A domain name is a sequence of labels separated by dots. The hierarchy is read not left to right but right to left: the rightmost label denotes the most general level.

def split_labels(domain_name: str) -> list[str]:
    """Splits domain name into labels; root is rightmost."""
    return domain_name.rstrip(".").split(".")


for domain in ["example.test", "www.example.test", "file.archive.example.test"]:
    labels = split_labels(domain)
    print(f"{domain:<27} {len(labels)} labels  verification order: {labels[::-1]}")

example.test                2 labels  verification order: ['test', 'example']
www.example.test            3 labels  verification order: ['test', 'example', 'www']
file.archive.example.test   4 labels  verification order: ['test', 'example', 'archive', 'file']

Reading this sequence on a tree gives the right intuition. The tree terminology from the Data Structures course applies here exactly as it does there: each label of the name is a node, and the full name is the path from the root to that node.

• The root is the dot at the very right of the name, and it is usually left unwritten. Writing example.test is shorthand for example.test.. The form with the trailing dot written out explicitly is called a fully qualified domain name.
• The top-level domain is the label directly under the root: test in the example.
• The label under that is the registered name: example.
• Labels further to the left are subdomains, created at the name owner’s own discretion: archive, file.

The www label carries no special meaning. It is an established convention; technically it is no different from any other subdomain. example.test and www.example.test are two separate names and can point to different places.

Label Rules

Labels are not free text. Their length is limited and their comparison rules are defined.

def split_labels(domain_name: str) -> list[str]:
    return domain_name.rstrip(".").split(".")


print(len("a" * 63))
print(all(len(label) <= 63 for label in split_labels("file.archive.example.test")))

63
True

A label can be at most 63 characters, and a full name at most 255 characters. These limits come from the field widths of the form in which the name is carried over the network.

Names are case-insensitive: EXAMPLE.TEST and example.test denote the same name. This rule, however, applies only to the name; it does not apply to the path portion of the address bar, and that distinction is covered in the Journey of a Web Request topic.

The native character set for names is limited to letters, digits and the hyphen. Names that contain characters outside this set — including non-ASCII letters — are represented with an encoding that maps back into the limited set. The distinction established in the character encoding lesson of the How Computers Work course holds here as well: the form shown to the user and the form carried over the network need not be the same.

The Delegation of Authority

The real function of the name hierarchy is not to look tidy but to divide responsibility.

An authority at the root level decides which top-level names will exist. That authority delegates management of the names under each top-level name to that name’s operator. When the operator hands the name example to an owner, authority over everything under example.test passes to that owner.

The consequence of delegation is this: creating the subdomain archive.example.test requires no one’s permission. The name owner has unlimited authority within its own subtree. The root authority is not even aware these names exist.

This is the same principle as the autonomous system structure from the previous lesson: singularity at the top level, autonomy at the lower level. The only thing that must be singular is who is authoritative at each level of the hierarchy.

Registration and Roles

Saying a name is “bought” is common but misleading. A name is not bought; a right of use is leased for a fixed term. If it is not renewed when the term expires, the name becomes available again.

Three roles are separated in the process, and confusing them is a common mistake.

Role	Function
Registry	Holds the single authoritative database of registrations under a top-level name
Registrar	Mediates between the name owner and the registry, and forwards the registration
Registrant	The person or organization holding the right of use for the name

There is exactly one registry per top-level name; registrars, in contrast, are numerous, and the name owner chooses among them. A name’s registrar can be changed; its registry cannot, because the registry is part of that top-level name’s definition.

The technically meaningful part of a registration is the declaration of which servers are authoritative for the name. The registry does not hold the address the name itself corresponds to; it holds only the information “ask these servers for this name’s answers.” The content of the answer is under the name owner’s control. This distinction underlies the resolution chain covered in the next lesson.

Reserved Names

Some top-level names are reserved and will never be opened to actual registration. test, example, invalid and localhost are among them.

This is why this course’s examples use the name example.test. A reserved name belongs to no one, does not resolve to an actual server, and will never pass into anyone’s ownership. Using a real name in the examples would make the example wrong the moment that name’s owner changed or its content diverged.

The same reasoning applies to the 192.0.2.0/24 address block used in the previous lesson: what is reserved for documentation can be used safely in an example.

Summary

• The name layer lets the value the user knows stay fixed even though the address can change; the real reason is not memorability but the ability to break this link.
• A domain name consists of labels and is read right to left, from root to leaves; the trailing dot denotes the root and is usually left unwritten.
• The www label carries no technical privilege; it sits at the same level as any other subdomain.
• Labels are at most 63 characters, full names at most 255; names are case-insensitive.
• The function of the hierarchy is to delegate authority: a name owner creates new names within its own subtree without asking permission.
• There is exactly one registry per top-level name, and it holds only the identity of the authoritative servers; the content of the answer is under the name owner’s control.

Next Step

The structure of a name and who owns it have now been established, but how a machine gets from that name to an address when example.test is typed into the address bar has not yet been said. The answer is not stored in a single place: the query follows a chain that starts at the root and advances one step at each level where authority has been delegated. The next lesson covers this chain and the caching scheme that keeps every request from running it from scratch.