Week 1 Day 4 — NETW-0001 Operating Systems Fundamentals

0:00–0:10
Recap

0:10–0:30
Lecture

0:30–1:45
Lab 2 Pt 3–5

1:45–1:55
Bonus

1:55–2:00
Wrap

0:00 – 0:10 Recap · 10 min

Path challenge and command warm-up

Two quick path challenges on the board — given a current directory, write the absolute and relative path to a target. Take answers verbally. Common mistake to look for: relative paths that start with / (those are absolute).
Ask: "What does ls -la show that ls alone doesn't?" — long format and hidden files. What makes a file hidden in Linux? (Answer: the filename starts with a dot. No special file attribute like Windows.)
Ask: "If I need to do something that requires admin rights in Windows, what do I do?" — Run as Administrator, UAC prompt. Preview: Linux has an equivalent — sudo — and today's lab introduces it.

0:10 – 0:30 Lecture · 20 min

find, grep, sudo — three tools that make the CLI genuinely powerful

sudo — borrowing superuser privilege (5 min)

Linux has a strict permission system — many system files and directories cannot be read or written by regular users. sudo (superuser do) lets an authorised user run a single command with root-level privilege. It's not the same as logging in as root — it's targeted, logged, and audited. Every sudo command is written to the system log.
Bridge: Windows UAC ("Do you want to allow this app to make changes?") is the visual equivalent. The key difference: sudo is command-specific, explicit, and logged. UAC is application-specific and gives the whole application elevated rights for its session.
Who can use sudo? Only users in the sudo group (on Ubuntu) or listed in /etc/sudoers. The student account was created during installation and is in the sudo group automatically. The lab explicitly requires sudo for Parts 3 onwards — this is intentional. Some of the directories we search belong to root.

find — locate files anywhere on the system (8 min)

find recursively searches a directory tree for files matching criteria. Unlike Windows Search (which indexes), find walks the filesystem in real time — it's slower but always current and works on any Linux system without configuration.
Core syntax: find [where] [what criteria] [what to do]. The "where" is required; criteria and action are optional (no criteria = list everything).

Flag	What it matches	Example
`-name "pattern"`	Filename — case sensitive. Use `-iname` for case-insensitive	`find / -name "beh"`
`-size +500M`	Files larger than 500 MB. Use `-` for smaller than, no sign for exact	`find / -size +500M`
`-mmin -10`	Modified in the last 10 minutes. `-mtime` for days	`find / -name "*.log" -mmin -10`
`-type f`	Files only. `-type d` for directories	`find /etc -type f -name "*.conf"`
`2>/dev/null`	Not a find flag — redirect errors to nowhere. Suppresses "Permission denied" noise	`find / -name "beh" 2>/dev/null`

grep — search inside files (7 min)

grep searches file contents for a matching string or pattern and prints every line that matches. Where find locates files by their properties, grep locates lines by what they contain. Bridge: Ctrl+F in a text editor — grep is the command-line version, but it can search hundreds of files at once.
Core syntax: grep [options] "pattern" [file(s)]

Flag	Effect	Example
`-i`	Case-insensitive match	`grep -i "student" /etc/passwd`
`-r`	Recursive — search all files in a directory tree	`grep -r "root" /etc/`
`-n`	Show line numbers	`grep -n "bash" /etc/shells`
`-c`	Count matching lines instead of printing them	`grep -c "bash" /etc/shells`
`-v`	Invert — show lines that do NOT match	`grep -v "nologin" /etc/passwd`
`*` wildcard	Search multiple files matching a pattern	`grep "root" /etc/pass*`

grep + pipe = power: grep becomes transformative when used in a pipeline. cat /etc/passwd | grep "student" is equivalent to grep "student" /etc/passwd — but the pipe approach lets you chain further. cat ~/.bash_history | grep "find" | wc -l counts how many times you've run the find command. You'll use this exact pattern in today's lab.

0:30 – 1:45 Lab 2 Parts 3–5 · 75 min

Lab 2 — Searching, text files, file operations, and disk usage

Parts 3, 4, and 5 of Lab 2, building on the directories created yesterday. The lab work today produces several files that will persist on the VM — don't delete them, they may be referenced in later labs.

Part 3 — Searching the filesystem with find and grep (25 min)

The following tasks use sudo — some directories are owned by root and cannot be searched without elevated privilege. Append 2>/dev/null to find commands to suppress permission-denied errors that clutter the output.
find tasks — record the command and result for each:
· Find the file named beh on the entire system: sudo find / -name "beh" 2>/dev/null
· Find a readable file that is exactly 10001 bytes: sudo find / -size 10001c -readable 2>/dev/null (c = bytes in find)
· Find all *.log files modified in the last 10 minutes: sudo find / -name "*.log" -mmin -10 2>/dev/null
· Find all files larger than 500 MB: sudo find / -size +500M 2>/dev/null
grep tasks — record the command and result for each:
· Search for the word student in /etc/passwd: grep "student" /etc/passwd. Identify and record: username, UID, GID, home directory, default shell — all are in that one line.
· Search for root in all files matching /etc/pass*: grep "root" /etc/pass*. What appears at the start of each output line when grep searches multiple files? (Answer: the filename, followed by a colon. This is grep telling you which file each match came from.)
· Count how many lines in /etc/shells contain the word bash: grep -c "bash" /etc/shells
· Using a pipe, count how many times you have used the find command so far this session: cat ~/.bash_history | grep "find" | wc -l. Record the number — it should match roughly how many find commands you've run today.

Instructor note — the /etc/passwd grep is a teaching moment: The fields in /etc/passwd are colon-separated: username:password placeholder:UID:GID:comment:home directory:shell. Walk through the student entry with the class. The "x" in the password field means the actual hash is in /etc/shadow, which is only readable by root. Ask: why keep the password hash in a separate file?

Part 4 — Creating and manipulating text files (30 min)

Create two text files in ~/lab2:
· echo "What did the limestone say to the geologist?" > ~/lab2/lab2.question.txt
· echo "Don't take me for granite!" > ~/lab2/lab2.answer.txt
· Verify both were created: ls -l ~/lab2/
Read the files — three ways:
· cat ~/lab2/lab2.answer.txt — outputs the entire file to the terminal
· less ~/lab2/lab2.answer.txt — opens in a pager (navigate with arrows, quit with q)
· more ~/lab2/lab2.answer.txt — similar to less, older tool
Record in your notes: which command would you use for a very long file, and why?
Check ownership: Run ls -l ~/lab2/ and record: who owns lab2.answer.txt? What group is assigned to it? (Should be student:student — you created it while logged in as student.)
Use the file command to identify file types — record all three results:
· file ~/lab2/lab2.question.txt — what type is it?
· file ~/lab2/backups (the directory from yesterday) — what type is a directory?
· file /usr/bin/grep — what type is grep? (It should say ELF executable — a compiled binary.)
Search both files with grep: Use man grep to find the flag that searches multiple files. Then search both lab files for the word "me". Record the exact command you used.
Copy and move files:
· Make backup copies of each file with a .bak extension: cp ~/lab2/lab2.question.txt ~/lab2/lab2.question.bak and the same for lab2.answer.txt
· Move both .bak files to the backups directory: mv ~/lab2/lab2.question.bak ~/lab2/backups/ and same for answer.bak
· Verify: ls ~/lab2/ and ls ~/lab2/backups/
Combine files into a new file using one command: The cat command can concatenate multiple files. Find a way to output both lab2.question.txt and lab2.answer.txt into a single new file called lab2.joke.txt, using one command. Record what you used. (Hint: cat file1 file2 > newfile)

Part 5 — Disk usage tools (20 min)

GUI tools first — understand what we're replacing: Open Files (the file manager) from the dock. Notice how little information it provides about directory sizes — you can't easily tell how much space each folder uses. Close it.
Open Show Apps → search "Disks" → open Disk Utility. Record in your notes: what is this tool for? Observe your partition layout — do the sizes match what you created during installation?
Open Disk Usage Analyzer (also from Show Apps → search "disk"). Navigate to your home folder. Record: how much storage space is the student home directory currently using?
Back to the terminal — the CLI versions are better:
· df -Th — disk filesystem usage, human-readable, with filesystem types listed (-T = type, -h = human-readable). Record: how much space are you currently using? How much is free?
· du -h --max-depth=1 ~ — directory sizes in your home folder, one level deep. Which directory uses the most space?
· du -h --max-depth=1 / (with sudo) — which directory in the root folder uses the most space?
Compare the GUI Disk Usage Analyzer result with the du command result for your home directory. Do they match? Record any differences and suggest why they might differ.

1:45 – 1:55 Bonus · 10 min

Piping, wc, and the man page habit

Build a pipeline that finds the 5 largest files in /var/log: sudo find /var/log -type f -size +0c 2>/dev/null | xargs sudo ls -lhS 2>/dev/null | head -6. Break down each part — what does each command contribute to the pipeline?
Explore man grep — navigate with arrow keys, search with /pattern, quit with q. Find the flag that inverts the match (shows lines that do NOT contain the pattern). Use it: grep -v "nologin" /etc/passwd — what does this show?
OverTheWire Bandit: Level 2 hides the password in a file with spaces in the name. Use what you learned today about quoting filenames. If you've reached Level 2, this should be very achievable now.

1:55 – 2:00 Wrap · 5 min

Tomorrow is the first mini-assessment — what to expect

Lab 2 should be complete by end of today. If you haven't finished Parts 3–5, complete them tonight — the practical assessment tomorrow draws from Lab 2 tasks directly.
Assessment format reminder: 30 minutes written (pen and paper — no computer), then 70 minutes practical (terminal tasks on desktop1). The written portion covers: OS concepts, filesystem hierarchy, absolute/relative paths, basic commands. The practical will ask you to navigate, find files, use grep, and create/copy/move files.
Best preparation: practice the commands from memory. Close this browser, open a terminal, and try to reproduce the lab tasks without the handout. The ones you can't remember are the ones to review tonight.

Learning outcomes — by end of Day 4, students can…

Use sudo appropriatelyExplain what sudo does, why it's preferable to logging in as root, and when it's required

Search with findLocate files by name, size, and modification time — suppress permission errors cleanly

Search with grepFind matching lines in files, count them, search multiple files, and pipe output through grep

Create and read text filesUse echo redirection to create files, and cat/less to read them

Copy and move filesUse cp and mv correctly, including renaming files by changing the target path

Check disk usageUse df -Th and du with depth and human-readable flags to report filesystem usage

What to have ready before class

Lab 2 Parts 3–5 handout printed Mini-Assessment 1 printed and ready for Friday Remind students to complete Lab 2 if not finished in class

←← Week 1 Overview ← Day 3 Lab 1D Handout Day 5 →