Linux Commands and File System Navigation

4.1 Inter-User Communication — write and wall

4.1.1 write — Two-Way Channel to a Single User

\$ who
mary  tty7  Sep 25 19:03
you   ttyA  Sep 25 23:01
\$ write mary
did you forget lunch? (o)

Message from you on ttyA at 23:02 ...
did you forget lunch? (o)

ten minutes (o)

ten minutes (o)
ok (oo)

Visual intuition: Picture two vertical terminal windows side by side, each with a prompt at the bottom. A horizontal arrow labeled write mary opens a pipe between them. Keystrokes flow as thin lines across the pipe; Ctrl + D is a valve that closes the pipe and the arrow disappears. The x-axis is time (before → during → after channel), the y-axis is who is typing. Landmarks: the Message from... banner at channel start, the (o) turn markers mid-stream, and the EOF/\$ at channel close. Takeaway: the channel is temporary and symmetric.

Real-world and domain connection: On multi-user servers, headless build machines, and early timesharing systems before Slack or Teams, write/wall were the sysadmin's coordination tools — a quick wall System going down in 5 minutes reaches every logged-in engineer without external dependencies. Today the same idea survives in tmux/screen messaging, DevOps jump hosts, and classroom lab servers where students share one machine. In systems programming, it illustrates the core UNIX idea that everything is a file — a terminal is just a writable file, and write is literally writing bytes to another user's terminal device file in /dev.

4.1.2 who and wall — Seeing Who Is Present and Broadcasting

\$ who
jib   tty0  Sep 25 13:59
you   tty2  Sep 25 23:01
mary  tty7  Sep 25 19:03
\$ wall
System will reboot at 23:30 for maintenance. Please save work. (oo)
Ctrl-D
Broadcast Message from you@server (tty2) at 23:25 ...
System will reboot at 23:30 for maintenance. Please save work. (oo)

Visual intuition: Imagine a server room with 6 terminals in a row; who lights up the 3 occupied seats (name tags above them, login time below). write draws one arrow from you to one lit seat; wall draws a fan of arrows from you to all lit seats simultaneously. Takeaway: discovery (who) must precede targeted talk (write), while wall skips targeting.

Real-world: In production, who and wall (or its modern cousin shutdown -r +5 "message") coordinate maintenance windows on shared department servers and HPC clusters — a wall before reboot prevents lost lab work when dozens share one login node. The same pattern — enumerate presence then message — recurs in Slack's /who and Kubernetes kubectl get pods before kubectl exec.

4.2 Manual Pages — man and the GCC Example

4.2.1 man — The On-System Manual Pager

man stands for manual. For any command you want to understand in depth you rely on man. It shows the description, synopsis, and every option with its meaning. You navigate inside the pager and press Q to quit — Q indicates quit — and you return to the prompt.

4.2.2 GCC Manual as a Rich Example

A concrete illustration is man gcc. GCC is the GNU Compiler Collection, which compiles C and C++ files. Its manual page first gives a short description and then enumerates a long list of options and their significance. The point is that you do not need to search the internet for this detail. An offline Linux system already carries the same material that you would later find rendered as HTML online; the HTML is generated from these same man pages. When you are logged into a Linux machine the manual is immediately available. This also explains a note about write: it had no interesting options to illustrate, so the demonstration switches to gcc where many options make the manual page structure visible.

4.3 Present Working Directory — pwd, Home Placement, and Hidden Startup Files

4.3.1 pwd — Print Working Directory

pwd stands for print working directory. It is often called present working directory and that phrasing is not wrong. It prints the absolute path of the directory you are currently in.

Examples shown in the session:

• Immediately after login, pwd returns /home/ubuntu because that is the current working directory.
• From there cd / followed by pwd returns / — you are in root.
• Bare cd with no argument returns you to your home, and pwd again shows /home/ubuntu.
• mkdir SP followed by cd SP and pwd shows /home/ubuntu/SP. Running ls in /home/ubuntu confirms that SP is one of the entries.

So ls and pwd complement each other: ls lists what is inside the current directory, pwd tells you where that current directory sits in the tree.

4.3.2 Where You Land on Login and the Hidden .bashrc File

Whenever you log into any system, the system places you in your home directory immediately. If you want to land elsewhere automatically, for example directly in a project folder, you do not need to type cd manually each time.

Every user home contains a hidden file named .bashrc. Hidden files are recognized because their name starts with a dot .. .bashrc is executed every time you log in. Opening it shows the script that runs at login. Putting a command such as cd /home/ubuntu/SP inside .bashrc will place you in that project directory right after login. The file is internal and normally not shown by plain ls; you will see why in the next section.

Understanding this matters for real work: shell startup files let you tailor the environment, and hidden dotfiles are the convention for configuration that should not clutter a normal listing.

Q: What else does ls show beyond regular files and subdirectories? A: By itself plain ls shows only regular files and subfolders. To see more — hidden entries, detailed metadata, sorting variations — you must add options. The long listing and the all flag are the first two to learn.

4.4 Listing Contents with ls — Meaning of . .. ~ and Every Common Option

ls is short for list. It lists the contents of the current directory — files and subdirectories or subfolders. Plain ls gives just names. The teaching value is in the options that reveal type, state, and history.

4.4.1 Long Listing with ls -l

ls -l — hyphen l for long — is long listing. It expands each entry into columns:

1. Permissions string for user, group, and others. The first column encodes who can read, write, and execute that file or directory. The session notes deferring the full user-group-other model but tells you to remember that column one is permissions.
2. Link count — how many links point to that inode. The session states it will not explain links yet.
3. Owner user.
4. Owner group — who has permission to work with the entry.
5. Size.
6. Time of creation or last modification.
7. Name.

So a long line tells you not just what exists, but how big it is, who owns it, when it was touched, and what you are allowed to do with it. This is the form you use when permissions or sizes matter.

4.4.2 All Entries Including Hidden with ls -a

Hidden files in Linux are not hidden by an attribute but by naming convention: any file or folder whose name starts with a dot . is hidden. Examples in a typical home include .bashrc and .gnupg. Both regular files and directories can be hidden this way.

• ls alone does not show these.
• ls -a — a for all — shows everything including hidden. The output then includes entries such as ., .., .bashrc, .gnupg alongside visible folders.
• ls -a -l or ls -al combines both: long detail for every entry including the dotfiles. In that combined view you can see . and .. themselves with their permission strings and other columns.

The distinction is visible directly: compare ls versus ls -a in the same directory and the extra dot-prefixed names appear.

4.4.3 The Special Directory Names . .. ~ and /

Four symbols form a shorthand for navigation and listing:

• . — a single dot indicates the current directory. It means same directory, and it is hidden in the naming sense. Demonstration: pwd says /home/ubuntu, then cd . and pwd again still says /home/ubuntu. Nothing moved. Similarly ls . lists the contents of the current directory and is identical in result to plain ls.
• .. — two dots indicate the parent directory. Demonstration: pwd shows /home/ubuntu, then cd .. moves to /home. Checking, /home is the parent of /home/ubuntu. Likewise ls .. lists the contents of the parent, not the current directory. It does not move you there; it only displays what is in the parent.
• ~ — tilde, described as the left-and-top key before 1 that you get with Shift, indicates the user home directory. ls ~ shows the contents of the user home, in the example the Ubuntu home, and the output matches plain ls when you are already in that home. cd ~ lands in the user home. Bare cd with no argument does the same thing.
• / — a single forward leaning slash is the root, the top level of the file system.

A common learner misinterpretation is to confuse .. with home or ~ with current. The correction repeated in the session is: . is current, .. is parent, ~ is user home, / is root. ls . is current, ls .. is parent, ls ~ is home.

Why two ways to go home, cd and cd ~? Historical usage: cd ~ existed first as the explicit way to say change to user home. Because people used it constantly, implementations added the shortcut that bare cd defaults to the user home. So both remain, doing the same job.

Combinations also make sense once the atoms are clear, though their printed output may look the same while the internal resolution differs:

• ls .. — parent directory contents.
• ls . — current directory contents.
• ls ../. — parent directory followed by its current entry. When the current directory is /home/ubuntu/SP and its parent is /home/ubuntu, this resolves to the parent's contents.
• ls ./.. — current directory followed by its parent. Same visible result in this tree, different traversal.
• ls -R would be recursive listing of all subfolders, but the immediate point is that dot and dot-dot are composable path components separated by /.

4.4.4 Sorting, Size, Inode, Reverse, Recursive and Human-Readable Options

Beyond l and a, the session walks through the manual page for ls and demonstrates each flag live:

• ls -t — t for sort by modification time, newest first. Example timestamps such as 17:58, 58:53 etc. become ordered with the most recent at the top. Plain ls or ls -l without t is sorted by name, not by time; adding t reorders by time.
• ls -S — capital S sorts by file size, largest first. Lowercase s does something different: ls -s prints the allocated size of each file in blocks. Capital S sorts, lowercase s prints. This pair is a frequent confusion point.
• ls -r — r for reverse. If ls shows F1 to zombie in name order, ls -r shows zombie to F1.
• ls -R — capital R for recursive. It descends into every subdirectory and lists their contents as well, for example showing /Desktop with nothing, /Music with users.txt, /OS with its files, /Pictures empty, and so on. It is the way to list an entire tree without entering each folder manually.
• ls -i — i for inode number. An inode number uniquely identifies a file on the file system. ls -i prints just the inode number alongside each name, for example F1 with its number, F2 with its number. The detailed inode discussion is deferred but the uniqueness property is stated.
• ls -h — h for human readable. With long listing it prints sizes in readable units rather than raw blocks. The manual describes it as human readable sizes.
• Combinations are normal: ls -al, ls -lah, ls -l -a -i and so on.

Real-world: In everyday work you combine these without thinking — ls -lah for all plus human sizes plus long detail, ls -lt to find what you just edited, ls -R to audit a project tree. The manual page man ls documents near a dozen variants such as --classify, --format, --sort and the session encourages reading it directly because details like -h versus no header have changed over versions.

Q: What option shows files of a specific type? Is it ls -lt? What does a mean? A: Not lt. ls -a is the flag for all, including hidden. ls -t sorts by time, ls -l is long. You identify hidden versus non-hidden by the leading dot in the name.

4.5 Creating Directories and Files — mkdir and touch and a Concrete Hierarchy

4.5.1 mkdir — Make Directories

mkdir stands for make directories. It creates directories. The syntax is mkdir followed by one or more names. Each name becomes a parameter and a separate folder is created.

You can create several siblings at once: mkdir dir1 dir2 dir3 creates three separate folders inside the current directory with a single command. This is faster than invoking mkdir three times.

4.5.2 A Practice Hierarchy Built Live

The session builds a sample hierarchy under the user home to exercise mkdir, cd, and touch together. The structure, using black for folders and red for files in the slide, is:

• sim1/ — top project folder under /home/ubuntu
• WI_Bangalore/ — sibling of bits and Wipro inside sim1
• STD1/
• STD2/
• bits/
• Goa/ — contains paper.doc only here
• Hyderabad/ — empty
• Pilani/ — empty
• Wipro/
• SIM/ — contains student.doc
• ways/ — written in the session as ways / WAYS / waste in spoken variants, containing student.doc

Live steps shown:

1. From home, mkdir sim1 or multiple names at once, then ls confirms sim1 appears.
2. cd WI_Bangalore then mkdir STD1 STD2 to make two siblings inside it.
3. Come back with cd .., then cd bits and mkdir Goa Hyderabad Pilani — three siblings. ls back in the parent confirms all three.
4. Back to parent, cd Wipro then mkdir ways SIM.
5. Verify with ls -R from sim1 which recursively lists Desktop, Music, OS, Pictures examples and then the sim1 tree, showing bits/Goa with paper.doc and bits/Hyderabad, bits/Pilani empty, and Wipro/SIM with student.doc and Wipro/ways with student.doc.

The point of the exercise is to create the identical tree on your own machine and share a snapshot taken recursively so the structure is visible without tree graphics. Plain ls -R output interleaves folder headers with their contents, which is how you confirm the shape.

4.5.3 touch — Create Empty Files

touch creates an empty file with zero bytes when the file does not exist. Example: touch tmp then ls -l shows tmp with size 0.

In the hierarchy, touch populates document slots:

• Inside Wipro/ways, touch student.doc creates the file.
• Inside Wipro/SIM, touch student.doc again creates the parallel file.
• Inside bits/Goa, touch paper.doc alone populates only that campus folder.
• Later a task asks to create info.txt inside WI_Bangalore. The correct form is touch WI_Bangalore/info.txt without entering that directory first.

The session also notes that touch with an explicit path both creates and sets an empty file you can later verify with ls -lR.

Student exchange on listing those files without entering each folder:

Q: If I want to check the contents of both Wipro/ways and Wipro/SIM from the parent without individually entering each folder, what should I give? A: Use recursive listing. ls -R or ls with the directory names as arguments while staying in Wipro shows first the two folder names present in Wipro and then the contents inside SIM and the contents inside ways. You do not need to cd into each.

4.6 Navigating with cd — Syntax Rules and Absolute versus Relative Paths

4.6.1 Command-Argument Separation

Every shell command expects the first word to be the command and the following words to be parameters or options. Writing a path before the command fails: typing W_Bangalore/touch/info makes the shell say W_Bangalore is not a command. The correct order is touch W_Bangalore/info.txt — command first, then path.

A second syntax rule: there must be a space between cd and its argument. cd .. with a space is correct in Linux. cd.. without a space is an error in Linux, though it happens to work in Windows. This is deliberate in Unix design: the command and its parameter are distinct tokens.

4.6.2 cd Variants and What They Do

• cd with no argument — goes to the user home directory, for example /home/ubuntu. This holds wherever you are, even if you are nested ten levels deep.
• cd ~ — ~ is the user home directory, so cd ~ is identical to bare cd in effect and is the older explicit form.
• cd . — dot is current directory, so you stay where you are. pwd before and after shows no change.
• cd .. — dot-dot is parent. From /home/ubuntu it moves you to /home. /home is the parent of /home/ubuntu.
• cd / — root.
• cd /home/ubuntu/sim1 — absolute form to a deep destination.
• cd sim1/bits/Goa — relative form from home to the same destination when sim1 is under the current home.

The session stresses precise language: bare cd and cd ~ return to the user home, which is /home/ubuntu for that user, not /home itself. /home is the parent that holds all user homes.

4.6.3 Absolute versus Relative Paths — Definitions and Three Variations

The distinction is central and the slide quoted in the session states it explicitly:

• Absolute path describes the location of a file or directory starting from the top level of the file system, which is root. It always starts with the forward leaning slash /. Irrespective of where you are, the absolute path to a destination is the same. Example from the lecture: /home/ubuntu/sim1/bits/Goa from any working directory still points to Goa. In scripts this stability is why absolute paths are preferred.
• Relative path describes the location relative to the present working directory. It never starts with /. Its spelling depends on where you are. Example: from user home, sim1/bits/Goa reaches Goa. From root you would need the absolute form.

Three variations demonstrated to reach the same Goa folder:

1. Relative from user home: cd sim1/bits/Goa. The argument does not start with /; it is resolved starting at the current directory which is /home/ubuntu.
2. Absolute from root: cd /home/ubuntu/sim1/bits/Goa. First / is root, then home, then user home ubuntu, then sim1, bits, Goa.
3. Relative via tilde from user home: cd ~/sim1/bits/Goa. ~ expands to user home, then the rest is appended. In this tree this is the same as variation 1 because ~ is /home/ubuntu.

The first and third are both relative — both are computed from a starting point that is not root — while the second is absolute and never changes even if you cd elsewhere first. The professor reads the slide to make the wording stick: absolute never starts without / and always starts with /, relative never starts with /.

Real-world: In industry you choose based on stability. For a script that must work no matter where the user invoked it, use absolute. For a quick interactive move or for portable project commands that should work on any machine where the project is checked out at a different root, use relative.

Q: Why have both cd and cd ~ if they do the same thing? Why not keep just one? A: cd ~ was the original explicit form — ~ meaning user home made the intent obvious. As people used the operation constantly, the shorter bare cd defaulting to home was added for convenience. Both remain so scripts and habits that use either still work.

Exam note: Expect to write both forms for the same destination and to label which is absolute and which is relative, explaining why absolute starts with / and relative does not.

4.7 Guided Navigation Exercises and Reasoning

The session turns the definitions into live tasks with student attempts and corrections. These exchanges are the clearest way to learn the pitfalls.

4.7.1 From STD1 to ways — Absolute and Relative

Prompt: you are currently in STD1 — clarified as sim1, effectively /home/ubuntu/sim1/WI_Bangalore/STD1 or sim1/WI_Bangalore/STD1 — change to ways which lives at sim1/Wipro/ways using both an absolute and a relative command.

Student attempts discussed:

• Absolute attempt: cd /home/ubuntu/sim1/Wipro/ways — correctly absolute because it begins with / representing root, then home, user home, sim1, Wipro, ways. It works from anywhere and does not change.
• Relative attempt that was marked incorrect: cd ~/sim1/Wipro/ways or cd sim1/Wipro/ways given while already inside sim1/WI_Bangalore/STD1. The reasoning correction is that while ~/sim1/... is technically a valid path from that starting point when expanded, a relative answer is expected to start from the present working directory, not from the user home. The relative path anchored at the actual present directory would be something like cd ../../Wipro/ways or cd /home/ubuntu logic aside, the point emphasized is that a true relative answer must be expressed as movement from where you are now via .., not as a fresh path from home. Solutions that ignored the present directory and re-anchored at home were called wrong for the purpose of the question even though the shell would accept them.

A correct relative answer shown: cd ../../Wipro/ways — .. to WI_Bangalore, another .. to sim1, then Wipro/ways. Another correct variant: cd /Wipro? No — cd /Wipro/ways was shown as the minimal relative that works if you interpret the slide's relative as from sim1 ( cd Wipro/ways ). The teaching correction is that relative must be relative to the present, so your path must begin with navigation from that present.

A related attempt using cd .. chain was accepted as relative: cd ../../../sim1/Wipro/ways from a deeper start still counts as relative because it begins with ...

4.7.2 Creating a File Under ways from Pilani Using Relative Path

Prompt: your present working directory is Pilani which is sim1/bits/Pilani. Create a file named after your bits ID, for example bitsID.doc, under the ways directory using a relative path.

The reasoning path needed: from Pilani, .. is bits, another .. is sim1, then Wipro/ways. So the relative path to the destination file is ../../Wipro/ways/bitsID.doc and the full command is touch ../../Wipro/ways/bitsID.doc. The session notes that understanding what . and .. expand to at each step is essential, and that tilde ~ would be wrong here because the task explicitly asks for relative to the present, not from home.

4.7.3 Absolute Creation Under STD1 from Sim

Prompt: assume you are in sim folder and you must create a file under STD1 using absolute path with your bits ID.

Correct pattern shown by peers: touch /home/ubuntu/sim1/WI_Bangalore/STD1/bitsID.doc or for the demo name touch /home/ubuntu/sim1/WI_Bangalore/STD1/bitsID.txt. Feedback given: Supraja's attempt was marked wrong because it omitted the root leading / required for absolute. Another peer missed the space between touch and the path — touchWI_Bangalore without a space is parsed as a command name that does not exist. Absolute always starts with /, includes home, the user directory, sim1, WI_Bangalore, STD1, and then the filename.

4.7.4 Where Does mkdir ./../newdir Create from Pilani?

Prompt: assume you are in Pilani under bits under sim1. If you run mkdir ./../newdir where will newdir be created?

Student split between bits and sim1. Resolution: break the argument into components. . is current which is Pilani. .. is parent which is bits. So ./.. from Pilani resolves to bits. Appending /newdir creates the new directory inside bits. If the command had been mkdir ../../newdir it would have been .. to bits, another .. to sim1, and creation inside sim1. So the answer is bits, not sim1. Two peers who said bits were correct.

Q: If mkdir argument is ../.. would it go to sim? A: Yes. Each .. moves one level up. From Pilani, one .. is bits, two .. is sim1. The given command has only one .. after the dot, so it stops at bits.

4.8 Creating and Editing Files — ed Versus touch

4.8.1 touch — Quick Empty File Creation

touch is presented as the easy recent way to create an empty file. touch filename makes a zero-byte file. In the demonstration touch tmp and then ls -l shows size 0.

4.8.2 ed — The Classic Buffer Editor Workflow

ed is introduced as the older editor family, available long before touch became common. Creating a file with ed requires several steps in sequence:

1. ed sample.txt — invoke the editor on the desired filename. If the file does not exist it reports no such file or directory but still opens the buffer.
2. a — for add. This enters input mode where subsequent lines are collected into the buffer.
3. Type the content, for example hello. I am typing things in a new file.
4. . on a line by itself — dot stops adding text.
5. w sample.txt — write. This writes the buffer contents into the named file.
6. q — quit the editor.

Demonstration shows ed sample.txt, then a, then text, then ., then w sample.txt, then q, then cat sample.txt displays hello. I am typing things in a new file. The point is that until w is given the text lives only in the editor buffer; w filename persists it.

4.8.3 Choosing Between touch and ed

Comparison made in the session: touch is very new — described as about five or six years in the surrounding narrative — and was not part of the old family of commands. ed belongs to the old family. For simple empty creation touch is preferred; for typed content the older ed shows the buffer-write-quit model that later editors inherit.

Exercise given: create a file letter.doc in folder1 using ed. The expected sequence is a to add, . to stop, w folder1/letter.doc or w letter.doc depending on your present directory, then q to quit. The four letters a, ., w filename, q summarize the model.

Q: Can I create a file as W_Bangalore/touch/info? A: No. The first word must be the command. W_Bangalore is not a command, so the shell reports not a command. The correct order is touch W_Bangalore/info.txt — command touch first, then the path as its parameter.

Q: Does ed warn before overwriting an existing file? If I create the same name again will it ask? A: No warning. Demonstrated with touch temp then ed overwriting temp with yay I am overriding, then ., w temp, q, and cat temp now shows the new single line. It just overwrites. Only access permissions can prevent writing; otherwise the editor assumes you intend the write. The session notes that permission-based protection will be covered later and is premature now.

4.9 Displaying and Combining Files — cat and Printing with pr

4.9.1 cat — Display and Concatenate

cat is both a display and a concatenation tool. Beyond cat file to show contents, cat file1 file2 > file3 concatenates. The session builds two files with ed to illustrate:

• Preparation: using ed, add this is first line then . then w sim1/Wipro/ways/student.doc, similarly this is my second line written to sim1/Wipro/SIM/student.doc. Then cat shows each file individually.

Then the task: create a new document named final.doc under Wipro whose content is the concatenation of student.doc under ways followed by student.doc under SIM, using absolute paths.

Correct construction uses cat with redirection: cat /home/ubuntu/sim1/Wipro/ways/student.doc /home/ubuntu/sim1/Wipro/SIM/student.doc > /home/ubuntu/sim1/Wipro/final.doc. The > takes the combined stdout of the two cats and writes it into the destination absolute path. The session initially tries cat to combine and shows the concatenation working.

4.9.2 pr — Formatting for Printing

pr is introduced for printing preparation. man pr says pr converts text files for printing. Since no printer is attached the demo skips actual printing, but notes key behaviors: every page has 66 lines, date and time header, multi-column options. Examples: pr file1 file2 for basic printing format, pr -3 file to print in three columns, pr -j to merge full lines without column alignment, pr -m to print all files in parallel one in each column. The takeaway is that pr formats rather than just dumps like cat.

4.10 Redirection > and Append >> — Building, Redirecting, and Updating Files

Two redirection symbols are contrasted:

• > — single greater-than — writes stdout into a file, creating the file if needed or overwriting it if it exists.
• >> — two greater-than — appends to a file, updating its contents without discarding what was already there.

Three concrete uses in the session:

4.10.1 Capturing ls Output

Assume your present working directory is Goa which is sim1/bits/Goa. Store the result of ls -l -a -i into a file results.txt in Goa itself.

Steps: cd sim1/bits/Goa to ensure present is Goa, then ls -l -a -i > results.txt. The command generates an output but the output is not printed on the screen; it is redirected into results.txt. Verifying with cat results.txt shows the long, all, inode listing that was generated.

4.10.2 Concatenation into a Final Document

As above, cat file1 file2 > newfile.txt uses > to write the concatenated contents into a new file. Example with absolute paths all three — two sources and the destination /home/ubuntu/sim1/bits/newfile.txt — succeeds only when each absolute directory actually exists; an early attempt failed with no such file or directory because the intermediate path /home/bits does not exist until written correctly as /home/ubuntu/sim1/bits.

4.10.3 Updating Versus Overwriting info.txt — Relative Path Pitfall

Prompt: you are in bits which is /home/ubuntu/sim1/bits. You wish to update the contents of info.txt which is present in WI_Bangalore — note WI_Bangalore is a sibling of bits inside sim1, not a child of home or root.

Three candidate commands are discussed, all claimed to use relative path:

1. /WI_Bangalore/... with leading slash — wrong because leading / means root. Under root WI_Bangalore does not exist.
2. ~/WI_Bangalore/... with tilde — wrong because ~ is user home /home/ubuntu, and under that WI_Bangalore does not exist. WI_Bangalore is under sim1, not directly under home.
3. The third variant also with tilde suffers the same location error.

So none of the three paths are correct in terms of location, and the correct missing path would need ../WI_Bangalore/info.txt from bits — .. to sim1, then WI_Bangalore/info.txt.

Beyond location, the update intent matters: the question says update the contents, not rewrite. To append you must use >> not >. A single > would replace the file; two >> appends.

Q: Which of the three options correctly updates info.txt using relative path? Several peers split between the second and third, one says none. A: None is correct for the location, because all three miss the sim1 component and misplace WI_Bangalore. For the operation, updating requires >>. An update would look like echo new line >> ../WI_Bangalore/info.txt from bits, using .. to reach sim1 first and >> to append.

Exam note: Expect traps of this form — a path that looks plausible but fails because WI_Bangalore is not under root or not directly under ~, and a symbol choice that tests whether you know append is >> while write is >.

4.11 Copying with cp and Statistics with stat

4.11.1 cp — Copy Options and Their Behaviors

cp copies contents from a source file to a destination file. It requires two parameters: source and destination, as in cp file1.doc file2.doc.

Demonstrated options, each with meaning:

• cp -i source destination — i for interactive. Prompts before overwriting. Example cp -i results.txt paper asks Do you want to overwrite? If you answer yes it overwrites; if no it keeps the destination. This guards against accidental overwrite.
• cp -p — p for preserve. Preserves mode, ownership, and timestamps of the source as is in the destination.
• cp -f — f for force. If an existing destination file cannot be opened, remove it and try again. Described as forceful copy.
• cp -R — capital R for recursive. Copies directories recursively. This copies a directory and all its contents.
• cp -u — u for update. Copies only when the source file is newer than the destination file, or when the destination is missing. If the destination is newer, no copy happens.
• cp -n — n for no overwrite. Does not overwrite an existing file. This stops you from accidentally overwriting.
• cp -v — v for verbose. Prints informative messages about what is being done.
• Additional options for symbolic links are mentioned but skipped because links have not been introduced yet, and the session says they will not appear in the immediate assessment.

The worksheet tasks repeat these: create two files with this is first file and this is second file as contents, then try cp -u in both time orders to see whether the update happens depending on which is newer.

4.11.2 stat — File Statistics Field by Field

stat gives statistics of a file. Example stat results.txt prints:

• File name.
• Size on disk and number of blocks consumed, plus the I/O block size.
• File type — regular file versus device file or character file. At this stage treat it as regular file; device details are deferred.
• Device ID.
• Inode number — the same unique number seen with ls -i — and how many links it has.
• Access permissions for user, group, and others.
• User ID and group ID — both 1000 in the demo because the file belongs to the ubuntu user.
• Three timestamps: access, modify, and change. The session explicitly says the difference between modify and change is subtle and will be clarified later; for now just note that they are distinct and you should try the commands to observe the difference.

Understanding stat lets you see the inode behind a name and the metadata that ls -l summarizes.

4.12 Moving and Removing — mv, rmdir, and rm

4.12.1 mv — Move

mv physically moves a file or directory from a source folder to a destination folder. Replace the word place with folder. Example mv results /home/ubuntu moves the file results into the user home.

Option mv -i — i for interactive — should ask before moving. Demonstration with mv -i from the current directory to home showed that in this environment it did not prompt, but the file still moved: checking the current directory shows it is no longer there, checking the home shows results.txt now present there. rm -i contrastingly does prompt.

4.12.2 rmdir — Remove Empty Directories

rmdir is remove directory but only for empty directories. It takes the directory name as a parameter and removes it only if it contains no files or subfolders. This restriction is intentional.

4.12.3 rm — Remove Files and Recursive Deletion

rm removes a single file. Examples:

• rm -i paper.doc — i for interactive — asks whether you want to remove the file. Answering no keeps it; yes removes. This was shown to work.
• rm -R — capital R for recursive — deletes all files in all subdirectories. Combined with f for force, rm -R -f or rm -rf deletes everything under the current working directory including folders, subfolders, and sub-subfolders without further prompting. This is forceful deletion, and the session warns to use it deliberately.
• rm -f also allows forced removal even if the file is write-protected, though the core teaching is recursive plus force.

Student interaction at the end clarifies a common confusion:

Q: rmdir did not work when the directory had folders and files inside. Can we remove a directory if it is not empty? A: Not with rmdir. rmdir only removes empty directories. To delete a directory even if it is not empty you need the options of rm, specifically the recursive and forceful form rm -R and rm -f. The exact command for non-empty directory removal is promised for the next class, but the principle — rmdir for empty, rm -R -f for everything — is established now.

Exam note: Expect to distinguish rmdir versus rm -R, and to know that rm -i prompts while rm -f forces.

4.13 Consolidated Practice — Worksheets and Copy/Move Tasks

4.13.1 Integrated Worksheet Set

Worksheets referenced in the session pull together the path and file operations:

• Create directories and files using both mkdir and touch or ed, then use cat with absolute paths to produce a combined file.
• Use cp with each option -i, -p, -f, -R, -u, -n, -v to observe overwrite prompting, preservation, forced removal, recursive copy, update-only-when-newer, and no-overwrite behavior.
• Use stat to inspect size, blocks, inode, links, permissions, UID/GID, and the three timestamps after copying.
• Use mv -i and rm -i, rm -R, rm -f to experience the interactive prompt difference and the power of recursive deletion.
• Use ls -l -a -i, ls -t, ls -S, ls -r, ls -R, ls -h, ls -s, and ls -s versus ls -S to internalize sorting and size reporting.

4.13.2 Execution Advice

The recurring advice is to try each command yourself exactly as shown, because parameters like /home/ubuntu/sim1 versus WI_Bangalore fail silently with no such file or directory until the path spelling matches the real tree.

Exam Guidance Summary

All marks-related guidance that appeared inline is collected here:

• Absolute path questions are trap-heavy: absolute always starts with / (root), relative never does. If a question asks for absolute, the answer must begin with /; if it asks for relative, it must be computed from the stated present working directory and must use .. correctly.
• Common wrong paths are those that place WI_Bangalore directly under root (/WI_Bangalore) or directly under user home (~/WI_Bangalore). In the constructed hierarchy WI_Bangalore lives under sim1, so a correct absolute is /home/ubuntu/sim1/WI_Bangalore/... and a correct relative from bits is ../WI_Bangalore/....
• Redirection symbol choice is tested: > is write or overwrite, >> is append or update. An update question expects >>. Writing a new file may use >.
• mkdir, cd, and touch syntax expects a space between command and argument; cd.. is incorrect on Linux though it works on Windows.
• ed overwrites without warning; there is no interactive guard like cp -i. Only permissions restrict it.
• ls sorting: t for time newest first, S for size largest first, r for reverse, R for recursive, i for inode, a for all, l for long, h for human readable, s for allocated blocks. Do not confuse s (print size) with S (sort by size).
• cp flags likely to be examined: i interactive before overwrite, p preserve mode ownership timestamps, f force, R recursive directories, u update only when source newer, n no overwrite, v verbose.
• stat contents: file name, size, blocks, I/O block, file type, device ID, inode number, link count, access permissions, UID/GID, access modify change times. Modify versus change has a subtle distinction to be detailed later.
• rmdir removes only empty directories; non-empty removal uses rm -R with optional -f for force. The full non-empty removal command beyond rmdir is deferred to the next lecture.
• pr formats for printing: 66 lines per page, headers, pr -3 three columns, pr -j merge lines, pr -m parallel. cat displays or concatenates; pr formats; ed edits; touch creates empty.
• Presentation advice implied: build the exact folder tree with mkdir taking multiple arguments at once and touch with explicit relative or absolute paths, then verify with ls -R.

Key Industry Applications

Real-world connections that appeared with the concepts:

• Real-world: GCC, the GNU Compiler Collection, as a canonical example of a command with dozens of options whose documentation you read offline with man gcc versus online HTML rendered from the same pages. The man system gives you internet-free reference on any Linux development machine.
• Real-world: Hidden shell startup file .bashrc that runs at login, used in practice to auto-cd into a project directory so every terminal session starts where you work, a standard developer workflow on shared servers and personal machines.
• Real-world: Two-way terminal chat via write and broadcast via wall paired with who to see who is available, historically used for sysadmin coordination on multi-user servers before modern chat tools.
• Real-world: Human readable ls -h, time-sorted ls -lt, size-sorted ls -S, and recursive ls -R for daily project navigation, build artifact inspection, and log triage, complemented by inode tools ls -i and stat for file system debugging and linkage checks.
• Real-world: touch as the modern quick way to create empty files and update timestamps in build systems, versus ed as the historical lineage of Unix editors whose a, ., w, q buffer model survives in tools like vi.
• Real-world: Path strategy in scripts — absolute paths from root /home/ubuntu/... for stable job configurations that must work from any working directory, and relative paths with .. and . for portable repository layouts where the checkout location varies.
• Real-world: File flow with redirection > for capturing ls -l into reports (ls -l -a -i > results.txt), concatenation with cat file1 file2 > final.doc for log merging or document assembly, and append >> for updating logs without losing history such as echo >> info.txt.
• Real-world: Copy guards cp -i to prevent accidental overwrite in production, cp -p to preserve ownership and timestamps during backups, cp -u for incremental updates where only newer sources propagate, and cp -R for directory trees, all mirrored in release engineering pipelines.
• Real-world: stat for forensics — checking inode numbers, block usage, ownership IDs, and access modify change times during debugging of build caches or deployment issues, with UID/GID 1000 as the typical single-user ownership marker.
• Real-world: Printing pipeline pr with 66-line paging and column merging for legacy report formatting, still referenced in documentation for text file preparation before sending to physical printers.