TSSR module 1: hardware and system fundamentals

Day 1 · 03/11 — A tour of the computer

Goal: name each part of a PC, say what it does, and find it in Windows.

Theory (20 min)

Almost every computer still follows the architecture John von Neumann described in 1945: a processor that runs instructions, a memory that holds both programs and data, and inputs and outputs.

• The processor (CPU) runs instructions. It has several cores, each able to follow its own thread of work, a clock speed (in GHz) and very fast cache memories (L1, L2, L3).
• Memory (RAM) holds running programs and their data. It is fast and volatile: everything is lost at power-off. Current modules are DDR4 or DDR5, which are not interchangeable.
• The motherboard connects everything: the processor socket, the memory slots, PCI Express slots for expansion cards, storage connectors and the rear panel ports.
• The chipset is the motherboard chip that handles part of the input-output (USB and SATA ports, extra PCIe lanes). It sets what a motherboard can do with a given processor.
• Storage keeps data at power-off: hard disk (HDD, magnetic platters), SATA SSD, or NVMe SSD plugged straight into PCI Express, much faster.
• Then come the power supply, the graphics card (built into the processor or separate) and the network card.

A driver is the software that lets the operating system talk to a component. A component without a driver shows up with an exclamation mark in Device Manager.

Practice (30 min)

1. Install the path's tools (VirtualBox, Packet Tracer, Wireshark, the notebook). Do not create the VMs yet: that is for days 4 and 6.
2. On your Windows machine, open Device Manager: Win + X, then "Device Manager". Expand Processors, Disk drives, Network adapters, Display adapters.
3. Open Task Manager (Ctrl + Shift + Esc), Performance tab: note the number of cores, the amount and type of memory, the type of each disk.
4. Run msinfo32: note the motherboard model and the BIOS version.
5. On Linux the equivalents are lscpu, free -h, lsblk and lspci.
6. Make a table in the notebook: part, model, one figure.

Recap (10 min)

Three lines: RAM versus storage, what the chipset does, what a driver is. Then, without notes, find the number of cores of your processor.

Day 2 · 04/11 — BIOS, UEFI and boot

Goal: tell what happens between pressing the button and the login screen, and change the boot order.

Theory (20 min)

Firmware is the first program that runs, stored on a chip on the motherboard. The BIOS of the first IBM PCs (1981) ruled for forty years; it has been replaced by UEFI, which grew out of the EFI Intel designed in the late 1990s and has been maintained since 2005 by the UEFI Forum consortium. UEFI boots GPT-partitioned disks, offers a graphical interface and Secure Boot, which refuses to start an unsigned boot loader.

1. POST (Power-On Self-Test): the firmware checks the processor, the memory and the essential devices. A failure at this stage shows as beeps or LEDs.
2. The firmware looks for a boot device in the configured boot order.
3. With UEFI, it reads the EFI system partition (ESP, in FAT32) and starts the boot loader: Windows Boot Manager, or GRUB on Linux.
4. The loader loads the system kernel, which mounts the file system, starts the services, then the login screen.

Connectors: USB (USB-A, USB-C; the connector does not tell the speed), HDMI and DisplayPort for video, RJ45 for Ethernet, the audio jack. Remember that the same USB-C connector can carry very different protocols.

Practice (30 min)

1. Find your machine's firmware key (often F2, Del, F10 or F12, shown at boot or in the maker's documentation). On Windows you can also go through Settings → System → Recovery → Advanced startup → Troubleshoot → UEFI Firmware Settings.
2. In UEFI, without saving anything, find: the firmware version, the Secure Boot state, the boot order.
3. Put the USB stick first in the boot order, then restore the original order. Exit without saving when in doubt.
4. Note each screen visited in the notebook.

Do not touch voltages, frequencies or the firmware update today: you are observing.

Recap (10 min)

Write the four boot steps from memory, then the BIOS/UEFI difference in one sentence.

Day 3 · 05/11 — Binary, hexadecimal and units

Goal: convert by hand between decimal, binary and hexadecimal, and never mix up GB and GiB again.

Theory (20 min)

A computer only handles bits, 0 or 1. A byte is 8 bits and takes 256 values, 0 to 255. In binary each position is worth a power of 2; for a byte, from left to right: 128, 64, 32, 16, 8, 4, 2, 1.

• Binary → decimal: add the weights of the positions set to 1. 1100 1010 = 128 + 64 + 8 + 2 = 202.
• Decimal → binary: subtract the weights from the largest to the smallest. 200 = 128 + 64 + 8 → 1100 1000.
• Hexadecimal (base 16): digits 0 to 9 then A to F (A = 10, F = 15). One hexadecimal digit is exactly 4 bits, so a byte is two digits: 1100 1010 = C A = 0xCA. You meet it in MAC and IPv6 addresses.

Units: the international system sets kilo = 1,000, mega = 10⁶, giga = 10⁹. In 1998 the International Electrotechnical Commission created the binary prefixes: kibi (KiB = 1,024 bytes), mebi (MiB = 1,024²), gibi (GiB), tebi (TiB = 1,024⁴). A disk sold as "1 TB" holds 10¹² bytes, about 931 GiB: that is why Windows, which counts in powers of 1,024 while writing "GB", shows less than the label. Network speeds are counted in bits per second: 100 Mbit/s is 12.5 MB/s.

Practice (30 min)

Twenty conversions by hand, no calculator:

1. Decimal → binary: 5, 17, 64, 100, 127, 128, 192, 224, 240, 255.
2. Binary → decimal: 1010, 1111 0000, 1000 0001, 0111 1111, 1110 0000.
3. Hexadecimal ↔ decimal: 0xFF, 0x80, 0x1A, 200, 172.

Then check with the Windows calculator in Programmer mode. The values 128, 192, 224, 240, 248, 252, 254, 255 come back in every subnet mask: learn them by heart.

Recap (10 min)

Write the weights of a byte from memory, then do three random conversions against the clock.

Day 4 · 06/11 — Installing Windows

Goal: pick a partitioning scheme, understand formatting, and create the Windows VM.

Theory (20 min)

Before it holds files, a disk is split into partitions, described by a partition table:

• MBR (Master Boot Record, IBM PC, 1983): four primary partitions at most (or three and an extended one), and disks limited to 2 TiB with 512-byte sectors.
• GPT (GUID Partition Table, from the UEFI specification): 128 partitions by default on Windows, disks well beyond 2 TiB, and a backup copy of the table at the end of the disk. Windows 11 requires UEFI, hence a GPT disk to boot.

Formatting creates a file system in a partition: NTFS for Windows (permissions, journaling, large files), FAT32 for the EFI partition and for sticks that must be read everywhere, exFAT for large files on removable media. On a blank disk, the Windows installer creates the EFI system partition itself, a small reserved partition (MSR), the Windows partition and a recovery partition.

Practice (30 min)

1. Download the Windows 11 Enterprise evaluation ISO from Microsoft's Evaluation Center (link on the path page).
2. In VirtualBox: New machine, type Windows 11. Give it at least 4 GB of memory, 2 processors, a 64 GB disk; check that EFI, TPM 2.0 and Secure Boot are on.
3. Boot from the ISO. At "Where do you want to install Windows?", look at the unallocated space, let the installer partition, then note the partitions it created.
4. Once Windows is up, open Disk Management (diskmgmt.msc): find each partition, its file system and its size.
5. Install the VirtualBox Guest Additions (Devices menu) for display and clipboard.

This evaluation edition asks for a Microsoft account at install; one created for the purpose is enough.

Recap (10 min)

Three lines: two MBR limits, why Windows 11 needs GPT, what the EFI partition is for.

Day 5 · 07/11 — Windows: users, groups, NTFS permissions, services

Goal: create accounts, give them different rights on a folder, and read a service's state.

Theory (20 min)

• Local accounts and groups: an account belongs to groups; rights go to groups rather than to people, so there is only one place to change. Useful built-in groups: Administrators, Users.
• NTFS permissions: every file and folder has an access control list (ACL). The standard permissions are Full control, Modify, Read & execute, List folder contents, Read, Write. A folder passes its permissions to its contents (inheritance). An explicit deny wins over an allow.
• User Account Control (UAC): even an administrator works with reduced rights and must confirm an administrative action.
• Services: programs running in the background, with no session open. Each has a startup type: Automatic, Manual, Disabled.

Practice (30 min)

1. In the Windows VM, open lusrmgr.msc, or else an administrator command prompt.
2. Create two accounts and a group:

   net user alice * /add
   net user bruno * /add
   net localgroup Accounts /add
   net localgroup Accounts alice /add

3. Create C:\Share\Accounts. Properties → Security → Advanced: disable inheritance (converting the inherited permissions), remove the Users group, give Modify to the Accounts group.
4. Sign in as alice: she creates a file. As bruno: access is denied.
5. Check on the command line: icacls C:\Share\Accounts.
6. Open services.msc: find the Print Spooler service, its state and startup type. Stop it, then start it again.

Recap (10 min)

Three lines: why give rights to a group, what inheritance is, which wins between allow and deny. Then redo step 3 on a second folder without notes.

Day 6 · 08/11 — Linux: distributions, installation, console

Goal: know what a distribution is and install the Debian VM without a graphical desktop.

Theory (20 min)

In 1991 Linus Torvalds released the Linux kernel. Combined with the tools of the GNU project, started by Richard Stallman in 1983, it makes a complete free system. A distribution is that system packaged: kernel, tools, installer, package manager and update policy. The main families:

• Debian (founded by Ian Murdock in 1993) and derivatives such as Ubuntu: .deb packages, the apt tool. Very common on servers.
• Red Hat Enterprise Linux and its relatives (Fedora, Rocky Linux, AlmaLinux): .rpm packages, the dnf tool. Very common in companies.
• Others too (Arch, openSUSE…); the basic commands are the same everywhere.

On a server you work in the console: a terminal where a command interpreter (the shell, often bash) reads what you type. The $ prompt means an ordinary user, # the root administrator.

Practice (30 min)

1. Download the Debian stable netinst image (amd64) from debian.org.
2. VirtualBox: new Debian 64-bit VM, 2 GB of memory, a 20 GB disk. Turn off VirtualBox's unattended install so you follow the installer yourself.
3. Install in "Install" (text) mode. Language, keyboard, hostname debian-lab, root password, an ordinary user, guided partitioning on the whole disk.
4. At "Software selection", untick the desktop environment, tick "SSH server" and "standard system utilities".
5. After the reboot, sign in and type cat /etc/os-release, then uname -r.

If you leave the root password empty at install, Debian creates no usable root account and gives sudo to your user. Both choices are valid; write down the one you make.

Recap (10 min)

Three lines: kernel versus distribution, two families and their package tool, $ versus #.

Day 7 · 09/11 — Linux: the file tree and basic commands

Goal: move around and handle files in the console without hesitating.

Theory (20 min)

On Linux everything starts from a single root, /; there are no drive letters. The FHS (Filesystem Hierarchy Standard) sets the main directories:

• /etc: configuration; /home: personal folders; /root: root's own.
• /var: changing data (logs in /var/log); /tmp: temporary files.
• /usr: programs and libraries; /bin and /sbin point into it on a recent Debian.
• /dev: devices; /proc and /sys: views of the kernel.

An absolute path starts from /; a relative path starts from the current directory. . is the current directory, .. its parent, ~ your home folder. Linux is case-sensitive.

Practice (30 min)

Fifteen commands, repeated until you type them without thinking:

pwd                      # where am I?
ls -la                   # list, hidden files included
cd /etc ; cd .. ; cd ~   # move around
mkdir -p lab/a/b         # create directories
touch lab/notes.txt      # create an empty file
echo "hello" > lab/notes.txt
cat lab/notes.txt        # print
cp lab/notes.txt lab/a/
mv lab/a/notes.txt lab/a/copy.txt
rm lab/a/copy.txt
rmdir lab/a/b
less /etc/services       # read page by page (q to quit)
head -n 5 /etc/passwd ; tail -n 5 /etc/passwd
grep ssh /etc/services   # search for a word
man ls                   # the manual

Do three rounds: the first reading, the second looking only at the comments, the third from memory.

rm does not go through a recycle bin: what is deleted is gone. Make a habit of running ls on the target before an rm.

Recap (10 min)

Three lines: absolute versus relative, where configuration and logs live, how to get help on a command. Then rebuild the lab tree without notes.

Day 8 · 10/11 — Linux: rwx permissions, chmod, chown, sudo

Goal: read and set Unix permissions, and redo the day 5 scenario.

Theory (20 min)

Every file has an owner, a group and three sets of permissions, inherited from Unix (Bell Labs, 1969): for the owner (u), the group (g) and others (o).

• r read (4), w write (2), x execute (1). On a directory, r lets you list it, w create or delete inside it, x enter it.
• -rw-r----- reads: file, owner read-write, group read, others nothing. In octal: 640.
• chmod 750 folder or chmod g+w file change permissions; chown user:group file changes the owner.
• sudo runs a command with root's rights, if /etc/sudoers allows it; every use is logged.

The difference from NTFS: three fixed categories instead of an unlimited list, and no automatic inheritance. POSIX ACLs (setfacl) exist for finer cases.

Practice (30 min)

1. As root (or with sudo), install sudo if needed and add yourself to its group: apt install sudo, usermod -aG sudo <your-user>, then sign in again.
2. Redo day 5:

   sudo adduser alice
   sudo adduser bruno
   sudo addgroup accounts
   sudo adduser alice accounts
   sudo mkdir -p /srv/share/accounts
   sudo chown root:accounts /srv/share/accounts
   sudo chmod 770 /srv/share/accounts
   ls -ld /srv/share/accounts

3. Test: su - alice then touch /srv/share/accounts/test (it works); su - bruno, same command (permission denied).
4. In the notebook, a two-column NTFS / Unix table: who gets the rights, which rights, inheritance, command-line tool.

Recap (10 min)

Translate 755, 640 and 700 into letters from memory, then rwxr-x--- into octal.

Day 9 · 11/11 — Linux: packages, processes, systemd

Goal: install software, watch processes, and drive a service.

Theory (20 min)

• Packages: a package holds software and the list of its dependencies. apt downloads them from the repositories declared in /etc/apt/sources.list (or /etc/apt/sources.list.d/), checks their signatures and installs what is missing. apt update refreshes the list, apt upgrade applies updates, apt install and apt remove add and remove.
• Processes: each running program has a number (PID) and a parent. ps aux lists them, top shows them live. kill PID sends the TERM signal (stop cleanly), kill -9 PID the KILL signal (immediate stop, no cleanup).
• systemd: the first process the kernel starts (PID 1) on Debian since version 8 (2015). It starts services, described by units. systemctl status|start|stop|restart|enable|disable name drives them; enable means "at boot", start means "now".

Practice (30 min)

sudo apt update
sudo apt install nginx
systemctl status nginx          # active (running)?
sudo systemctl stop nginx
systemctl is-active nginx       # inactive
sudo systemctl start nginx
sudo systemctl disable nginx    # will no longer start at boot
sudo systemctl enable nginx
ps aux | grep [n]ginx           # the nginx processes
top                             # q to quit

Run sleep 600 &, find its PID with ps, stop it with kill. Note the difference between stopping a service with systemctl stop and killing its process: systemd may restart a killed service, depending on its configuration.

Recap (10 min)

Three lines: update versus upgrade, start versus enable, TERM versus KILL. Then install and drive another package (htop) without notes.

Day 10 · 12/11 — Maths refresher

Goal: compute quickly and correctly what networking needs: powers of 2, precedence, integer division.

Theory (20 min)

• Precedence: brackets, then powers, then multiplication and division, then addition and subtraction, left to right. 2 + 3 × 4 = 14, (2 + 3) × 4 = 20.
• Powers of 2, to know by heart up to 2¹⁶: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1,024, 2,048, 4,096, 8,192, 16,384, 32,768, 65,536. 2^a × 2^b = 2^a+b.
• Integer division and remainder: 200 ÷ 64 = 3, remainder 8. That is the calculation that finds which subnet an address falls in.
• How many hosts? With n host bits, 2ⁿ addresses, minus 2 (network and broadcast): 2ⁿ − 2.

Practice (30 min)

Fifteen calculations without a calculator: 2¹⁰; 2⁷ + 2⁶; 256 − 32; 2⁵ − 2; 2⁸ − 2; 3 + 4 × 2³; (3 + 4) × 2³; 200 ÷ 32 (quotient and remainder); 130 ÷ 64; 255 − 192; 1,024 ÷ 8; 65,536 ÷ 256; 2¹² ÷ 2⁴; 100 × 8; 12.5 × 8. Check, then redo the ones you missed.

Recap (10 min)

Write the powers of 2 up to 65,536 from memory, then the host-count formula.

Day 11 · 13/11 — Technical English

Goal: know twenty words that come back in every piece of documentation, and read a short article.

Theory (20 min)

Documentation, error messages and forums are almost all in English. For a French-speaking learner, these twenty words come first; if English is your first language, use the session to learn their French equivalents, which the course will use.

Practice (30 min)

1. Make flashcards (or cards in the notebook): the word on one side, its meaning and an example sentence on the other.
2. Read a short article on a topic already covered: for example the man ls page of your Debian VM, or a Debian or Microsoft Learn page on user accounts. Underline every unknown word and add it to the cards.
3. Summarise the article in two sentences.

Recap (10 min)

Hide the meaning column and explain the twenty words from memory.

Day 12 · 14/11 — Storage: disks, RAID 0/1/5, 3-2-1 backup

Goal: pick a RAID level, and never mistake it for a backup.

Theory (20 min)

RAID was formalised in 1988 by David Patterson, Garth Gibson and Randy Katz at Berkeley: combine several disks for speed, fault tolerance, or both.

• RAID 0 (striping): data is spread over all disks. Full capacity, speed, no tolerance: lose one disk, lose everything.
• RAID 1 (mirror): each disk holds everything. Half the capacity is lost; it survives the loss of one disk.
• RAID 5: at least three disks, data and parity spread over all of them. Capacity of n − 1 disks, survives the loss of one disk; parity lets the missing block be recomputed (with an exclusive OR). Rebuilding is long and stresses the remaining disks.
• RAID 6 (two parities, two failures tolerated) and RAID 10 (striped mirrors) are common on servers.

RAID protects against a disk failure, not against deletion, ransomware or fire: a mistake is copied to every disk at once. Hence the 3-2-1 rule: three copies of the data, on two different media, one of them off site.

Practice (30 min)

1. Draw by hand a RAID 5 over three disks and four stripes: place data blocks D1 to D8 and parities P1 to P4, with the parity moving to another disk at each stripe.
2. Cross out one disk: show how to rebuild each lost block from the other two.
3. Work out the usable capacity of three 4 TB disks in RAID 0, 1 (two disks only), 5.
4. Write the 3-2-1 plan of your own data: where are the three copies today?

Recap (10 min)

Three lines: what each RAID tolerates, why RAID is not a backup, the 3-2-1 rule. Redraw the RAID 5 without notes.

Day 13 · 15/11 — Virtualisation: hypervisors, VMs, snapshots

Goal: tell the hypervisor types apart, and roll back with a snapshot.

Theory (20 min)

Virtualisation was born on IBM mainframes in the 1960s; VMware brought it to the PC in the late 1990s. A hypervisor shares one physical machine between several virtual machines, each with its own virtual processor, memory, disks and network cards.

• Type 1 ("bare metal"): installed straight on the hardware. VMware ESXi, Microsoft Hyper-V, Proxmox VE (KVM). The server kind.
• Type 2: an application inside an existing system. VirtualBox, VMware Workstation. The workstation and lab kind.

A snapshot freezes a VM's state at one moment: its disks, and possibly its memory. Reverting to it cancels everything that came after. It is a safety net for experiments, not a backup: it lives on the same disk as the VM.

VirtualBox's network modes matter later: NAT (the VM reaches the Internet but cannot be reached), NAT Network (several VMs share a network that reaches the Internet), Bridged (the VM sits on your network like a real machine), Internal network and Host-only (isolated).

Practice (30 min)

1. With the Debian VM powered off: Machine → Snapshots → Take, name it "clean-day13".
2. Start the VM and break it on purpose: sudo rm /etc/hostname and sudo apt remove --purge nginx.
3. See the damage (cat /etc/hostname, systemctl status nginx), power off.
4. Restore the snapshot, boot, check that everything is back.
5. Put both VMs on the same VirtualBox "NAT Network": it will be the lab network for module 3.

Recap (10 min)

Three lines: type 1 versus type 2, what a snapshot holds, why it is not a backup. Do one snapshot-break-restore cycle without notes.

Day 14 · 16/11 — Module 1 review

Goal: measure what you have learnt, and replay the Linux work of days 7 to 9 with no help.

Theory (20 min): your 30-question quiz

Write thirty questions yourself from your notebook, at least two per session, then answer them the next morning or at the end of the session without looking. Ten to start with:

1. What does RAM lose at power-off, and why?
2. What does the POST do?
3. What is 1110 0000 in decimal? And 0x3F?
4. Why does a 1 TB disk show about 931 GB in Windows?
5. Two differences between MBR and GPT?
6. Which wins, an NTFS deny or an allow?
7. Where are the logs on Linux?
8. What does chmod 640 mean?
9. What is the difference between systemctl start and systemctl enable?
10. How many disks can a RAID 5 lose?

Practice (30 min)

Without notes, in the Debian VM: create a user and a group, a shared directory reserved for that group, check the rights with two accounts, install a package, stop and restart its service, find its PID. Time yourself; note every command where you hesitated.

Recap (10 min)

Count your right answers. The missed questions are the first thing to reread at the start of module 2.