Glossary

A computer that exists to answer other computers rather than to be sat in front of. Usually has no screen, and is reached over a network.

See also: client, host

Whichever side of a conversation started it. Client and server are roles taken for one exchange, not kinds of machine — the same computer can be both within a second.

See also: server

Any machine on a network, named from the network’s point of view. A host has addresses and answers to them; it is not necessarily a server.

See also: server, router

The part of the operating system that actually talks to the hardware and decides which program gets the processor next. Linux itself is a kernel; everything around it is the distribution.

An identity a machine recognises, stored as a number. Most accounts on a server are not people — they exist so that a service owns its own files.

See also: account, group

A line in /etc/passwd: a name, a number, a home directory and a login shell. Creating one is writing that line.

A record a program writes as it runs, so somebody can find out afterwards what happened. Usually a file under /var/log.

A file the machine can execute. Sitting on disk it is a program; once started it is a process.

Where a running program keeps what it is working on. Emptied when the machine restarts, unlike a disk.

Where files survive being switched off. On Linux a disk is not a drive letter — it is attached somewhere inside the single tree that starts at /.

One yes-or-no. Permissions are nine of them, which is why they can be written as three digits.

Putting a new version of an application onto the machines that run it. Kept in English because Georgian has no verb that carries the same meaning, and it is the word every team uses.

The program that reads what you type and runs it. Kept in English throughout the course because it is the word used in every manual and job advert; the Georgian გარსი appears once, as a gloss.

See also: terminal, prompt

The window the shell runs inside. The terminal shows text and takes keystrokes; the shell is what gives them meaning. Two things, often confused for one.

The text the shell prints when it is ready for a command. It usually says who you are, which machine you are on and where you are standing.

A program you ask the shell to run, plus whatever you tell it to work on. The first word is the program; everything after it is arguments.

A file of commands run in order, so a thing you did once can be done again exactly. Made executable, it is indistinguishable from any other program.

A name holding a value inside the shell. Written without a dollar sign and read with one, which is the source of most early confusion.

Standard output: where a program writes its results by default. Kept in English because it is what the manuals and error messages call it. Its sibling stderr carries complaints, so the two can be redirected apart.

See also: pipe

The `|` symbol, which sends one program’s output straight into the next program’s input. Nothing touches the disk in between.

See also: stdout

What you give a command to work on. Everything after the first word on the line is one.

What `if` tests. In a shell it is not true-or-false but a command’s exit status — zero means it worked, and `if` treats that as yes.

Doing the same thing to each of several items, with `for` or `while`, instead of typing it out once per item.

Standard error: the second output stream, carrying complaints. Separate from stdout so that a pipeline can process results while errors still reach you.

See also: stdout

Several commands joined by `|`, each feeding the next. Kept in English because it is also the word for a CI/CD pipeline, and the two ideas share a shape.

See also: pipe

The `#!/bin/bash` on a script’s first line, saying which interpreter should run it. Without it the file is text, not a program.

A named piece of data on disk. On Linux almost everything is presented as one, including devices and running-system information that are not really files at all.

A file that contains a list of other files. Called a directory rather than a folder throughout, because that is the word every Linux tool and manual uses.

Where a file is, written out. Absolute if it starts at `/`, relative if it starts wherever you happen to be standing.

Your own directory, /home/NAME, where a session starts and where your files live. ~ is short for it, and cd with no argument takes you back to it.

See also: directory, path

A file whose contents are the path of another file. Follow it and you arrive somewhere else; delete the target and it points at nothing.

See also: file, path

What a given account may do with a given file: read it, change it, or run it. Recorded as nine bits on the file itself, shown by `ls -l`.

The account a file belongs to. Owners get the first of the three permission groups, and can change the file’s permissions even when they cannot read it.

A named set of accounts, so several people can share files without making them readable by everybody. An account has one primary group and any number of others.

The administrator account, user number zero. Permission checks are skipped for it entirely — which is why the course spends so long on how not to be it.

See also: sudo

Run one command as somebody else, usually root. Reads /etc/sudoers to decide whether you may, and logs that you did.

See also: root

A running program, with its own number, its own memory and an account it runs as. The same program run twice is two processes.

A program meant to run continuously and be restarted when it stops — a web server, a database. Managed by systemd rather than started by hand.

systemd’s own record of what every service did, queried with `journalctl`. Deliberately not a file you can open: it is a structured store, searched by field.

See also: log

A short message sent to a running process, usually asking it to stop. `kill` sends one; it does not necessarily kill anything.

The files a program reads at start-up to decide how to behave. Changing one does nothing until the program is restarted and reads it again.

A process that runs in the background with no terminal attached, waiting to do its job. Almost every service is one.

systemd’s name for one thing it manages — a service, a timer, a socket. Kept in English because it is what `systemctl` prints and what the filenames say.

See also: service

Software plus the list of what it needs and where its files go, as one installable unit. Note that Georgian uses პაკეტი for both this and a network packet — two unrelated ideas, one word.

See also: packet, dependency

Another package that this one needs in order to work. The package manager follows them for you, which is most of what makes it worth having.

Putting a program on a machine along with everything it needs to run — done through the package manager, not by copying files into place.

A server holding packages that a machine is willing to install from. Listed in /etc/apt/sources.list, and trusted by the machine that lists it.

Code shared by several programs rather than built into each. Usually installed as a package of its own, which is why removing one can break something unrelated.

Which release of a package is installed. Debian versions carry the upstream number and its own packaging revision, separated by a dash.

`apt update` refreshes the list of what is available; `apt upgrade` installs it. Two different operations, and the first one alone changes nothing.

A configuration file a package ships and dpkg tracks by checksum, so an upgrade can tell whether you edited it and leave your version alone if you did.

Machines that can send each other messages, plus the agreements that let them. The agreements matter more than the cables — almost every fault is a disagreement, not a break.

The number identifying a machine on a network, such as 10.0.1.10. Meaningless on its own: it needs a netmask to say which part of it names the network.

See also: subnet, netmask

Everything plugged into one link, which can talk directly without help. Distinct from a cable: three machines through a switch share one wire but not one cable.

See also: cable, switch

The physical thing between two sockets. Carries signals and knows nothing about who they are for.

See also: wire

The envelope carrying an address that survives the whole journey, so it can reach a machine you have no cable to. Georgian uses პაკეტი for this and for a software package alike.

See also: package, frame

The outermost envelope, addressed to the next machine on this wire and thrown away at every hop. Kept in English beside packet and segment so the four layers read as one named set.

See also: packet

A machine with a foot in two networks, willing to carry packets between them. Written როუტერი — never რაუტერი.

See also: gateway, route

The router a machine hands anything it cannot reach itself. The default gateway is the one used when no more specific route matches.

See also: router, route

A rule saying where to send packets for a given range of addresses. The routing table is the list of them, and the most specific matching rule wins.

See also: gateway

A block of addresses treated as one local network. Whether another address is in your subnet decides whether you speak to it directly or hand it to a gateway.

See also: netmask, address

The part of an address that names the network rather than the machine, written as the number after the slash. Two machines on one wire with different masks cannot talk.

See also: subnet

The box that joins several machines into one wire. Reads hardware addresses only, and has no idea what an IP address is.

See also: wire, router

A number saying which program on a machine a message is for. One address, many ports, so a web server and a database do not get each other’s post.

A program’s claim on an address and port. A socket bound to 127.0.0.1 answers only on the machine itself; one bound to 0.0.0.0 answers everywhere.

A network connection as the machine sees it, such as eth0. Carries the addresses; `lo` is the one that goes nowhere near a cable.

One machine passing a packet along on its way. Each hop subtracts one from the packet’s TTL, which is how you count them from the other end.

Rules deciding which connections a machine accepts. A blocked packet is dropped without reply, so it looks like silence rather than refusal.

The machine talking to itself, at 127.0.0.1. Kept in English because it is what `ip addr` prints. Never leaves the computer, and no firewall filters it.

An agreement about what some bytes mean, so two machines that have never met can understand each other.

The system that turns names into addresses. A separate system that can be wrong on its own, which is why a site can work by address and not by name.

See also: address

One of the envelopes a message is wrapped in, each addressed to a different recipient. Each piece of equipment reads only its own.

See also: packet, frame

Everything moving across a network, taken together. Usually said when talking about volume or direction rather than any one message.

The hardware address of a network interface, used only on the wire it is attached to. Rewritten at every hop, so it never identifies a distant machine.

See also: frame, address

How a machine finds the hardware address of a neighbour it only knows by IP address. Asks the whole wire out loud, and the machine holding that address answers.

See also: MAC address, wire

Time to live: a number every packet carries, reduced by one at each router. It stops packets circling forever, and counting down from 64 tells you how many hops away a reply came from.

See also: hop

A message sent to everything on a wire rather than to one machine. Everything that receives it is in the same broadcast domain, which is what a subnet really is.

See also: wire, switch

How a machine is handed an address, a netmask and a gateway when it joins a network, instead of being configured by hand.

See also: address

The `10.0.1.0/24` notation: an address plus how many leading bits name the network. The way every modern tool writes a subnet.

See also: netmask, subnet

How you get a shell on another machine, encrypted. The reason a server needs no screen and no keyboard.

See also: host, port