Unix / Linux

Unix and Linux are the backbone of every server and cloud instance. TCS ILP tests this in FA — expect 5 MCQs plus it's the minor subject in Round 2 (15-20 marks).

What is Unix/Linux?

Why should you care? Every server you'll ever work with at TCS runs Linux. Every cloud instance (AWS, Azure, GCP) runs Linux. Every Android phone runs a Linux kernel. When you deploy your Java web app at work, it's going to a Linux server. You won't be clicking icons — you'll be typing commands in a terminal. That's Unix.

Think of it like this: Windows is a car with automatic transmission — you click buttons, drag things around, the OS handles the details. Unix/Linux is a manual transmission — you tell it exactly what to do, command by command. More effort to learn, but total control once you know it.

Unix was built at Bell Labs in 1969. Linux is a free, open-source recreation of Unix by Linus Torvalds (1991). For exam purposes, treat them as the same thing.

File System Hierarchy

Why does this matter? In Windows, you dump everything into C:\Users or wherever you want. Unix is organized like a well-planned office building — every department has its floor, and if you need something, you know exactly which floor to go to.

The entire Unix file system is one giant tree starting from / (root). There are no drive letters like C: or D:. Everything lives under /.

Think of it as an apartment building:

Essential Commands — Quick Reference

Why learn these? In Unix, there's no "right-click > New Folder" or "drag file to trash." Everything happens through commands. Think of each command as a verb — ls = "look", cd = "go to", cp = "copy", rm = "delete". Once you learn 20 verbs, you can do anything.

Don't memorize this table. Read through it once, then use the practice questions to test what stuck. Come back to this table as a reference.

File Permissions

Why do permissions exist? Imagine you work in an office building. Not everyone should have access to every room. The intern shouldn't be able to edit the CEO's files. The accountant shouldn't be able to delete the codebase. Unix permissions are like security badges — they control who can open which doors and what they can do once inside.

Every single file and folder in Unix has a permission badge attached to it. This badge answers three questions for three groups of people:

For each group, Unix tracks three things (WHAT they can do):

Reading Permission Strings

When you run ls -l, you see something like this:

# ls -l output:
-rwxr-xr--  1  darshan  staff  1234  Mar 18  script.sh
 ↑↑↑↑↑↑↑↑↑
 │└──┴──┴── owner(rwx) group(r-x) others(r--)
 └ file type: - = file, d = directory

Read it like a sentence: "This is a file (-). The owner (darshan) can read, write, and execute it (rwx). The group (staff) can read and execute but NOT write (r-x). Everyone else can only read (r--)."

Numeric (Octal) Permissions — The Math

Why numbers? Typing chmod 755 is faster than typing chmod u=rwx,g=rx,o=rx. Each permission has a number value, and you just add them up per group.

How to calculate: Add the values for each group separately. Three groups = three digits.

chmod 755 file.sh   # rwxr-xr-x → owner:7(rwx), group:5(r-x), others:5(r-x)
chmod 644 file.txt  # rw-r--r-- → owner:6(rw-), group:4(r--), others:4(r--)
chmod 777 file      # rwxrwxrwx → everyone full access (DANGEROUS!)
chmod 400 secret    # r-------- → owner read-only, nobody else can touch it

Symbolic Permissions — The English Way

Instead of math, you can use letters. The format is: WHO (+/- WHAT)

chmod u+x file     # u(owner) +(add) x(execute) → "give owner execute permission"
chmod g-w file     # g(group) -(remove) w(write) → "take write away from group"
chmod o+r file     # o(others) +(add) r(read) → "let others read"
chmod a+x file     # a(all) +(add) x(execute) → "everyone can execute"

grep — Pattern Searching

Why does grep exist? Imagine you have a 10,000-line server log and something crashed at 3 AM. Are you going to read all 10,000 lines? No. You want to search for "error" or "failed" and see only those lines. That's grep — it's Ctrl+F for the terminal, but way more powerful.

The name grep stands for "Global Regular Expression Print" — but just think of it as "search."

grep "error" log.txt          # find lines containing "error"
grep -i "error" log.txt        # case-insensitive (catches Error, ERROR, error)
grep -r "TODO" ./src/          # search ALL files inside src/ folder
grep -n "main" app.py          # show which LINE NUMBER each match is on
grep -c "error" log.txt        # just tell me HOW MANY lines matched
grep -v "error" log.txt        # show lines that DON'T contain "error"

grep -ic "nullpointerexception" server.log

Pipes and Redirection

Why do pipes exist? Remember the Unix philosophy — small tools chained together? Pipes are the chains. Each command does one thing well, and the pipe (|) connects them like LEGO bricks snapping together.

Think of it like a factory assembly line. Worker 1 cuts the wood, passes it to Worker 2 who sands it, who passes it to Worker 3 who paints it. Each worker is a command. The conveyor belt between them is the pipe.

Pipes (|) — The Assembly Line

The pipe takes whatever a command prints to the screen and feeds it as input to the next command. The data flows left to right.

ls -l | wc -l                  # ls lists files → wc counts the lines = number of files
cat file.txt | grep "error"    # cat shows file → grep filters only "error" lines
ps aux | grep "nginx"          # ps shows all processes → grep finds "nginx"
cat names.txt | sort | uniq  # show → sort alphabetically → remove duplicates

Redirection — Saving Output to Files

Why? By default, commands print output to your screen (called "stdout"). But what if you want to save it? Redirection lets you reroute the output into a file instead of the screen. Like redirecting a river into a canal.

Process Management

Why learn this? When your Java app hangs on a server, you can't just click the X button — there's no GUI. You need to find the frozen process and kill it from the terminal. Process management is how you become the Task Manager of a Linux server.

Think of processes like apps running on your phone. You can see which ones are running (ps), watch them in real-time (top), close them nicely (kill), or force-close a frozen one (kill -9).

Every running program is a process. Each process gets a unique number called a PID (Process ID) — like an employee ID badge. You use the PID to target a specific process.

Viewing Processes

ps               # show YOUR processes only
ps aux           # show ALL processes, ALL users (the one you'll use most)
top              # live dashboard — updates every second (press q to quit)

Killing Processes

Unix uses "signals" to communicate with processes. Think of it as sending a message:

kill 1234        # SIGTERM — "please shut down gracefully" (process CAN refuse)
kill -9 1234     # SIGKILL — "you're done NOW" (process CANNOT refuse)

Background and Foreground

./script.sh &    # run in background — terminal stays free for other commands
Ctrl+C           # terminate the currently running foreground process
Ctrl+Z           # suspend (pause) the foreground process — it's still alive but frozen
bg               # resume a suspended process in the background
fg               # bring a background process to the foreground

tar and gzip

Why? You know how you right-click a folder in Windows and "Send to > Compressed (zipped) folder"? Unix has two separate steps for this: tar bundles files together (like putting papers in a folder), and gzip compresses the bundle (like vacuum-sealing the folder to make it smaller). Usually you do both at once.

tar = Tape ARchive. It was originally for saving files to tape drives. Today it bundles files into one archive.

tar -cvf archive.tar dir/      # Bundle dir/ into archive.tar (no compression)
tar -xvf archive.tar           # Unpack archive.tar
tar -cvzf archive.tar.gz dir/  # Bundle AND compress (z = gzip)
tar -xvzf archive.tar.gz       # Decompress AND unpack
gzip file.txt                  # compress single file → file.txt.gz (original deleted!)
gunzip file.txt.gz             # decompress → file.txt

sed — Stream Editor

Why does sed exist? You need to replace "http" with "https" in 500 config files. Or delete all blank lines from a log. Or change every occurrence of a username. You're NOT going to open each file and Ctrl+H manually. sed is the "Find and Replace" of the terminal — it processes text automatically, line by line, at machine speed.

Think of sed like a factory worker on an assembly line. Each line of the file rolls past on a conveyor belt. The worker applies one rule (replace this, delete that), and the modified line comes out the other end. The worker never sees the whole file at once — just one line at a time.

Substitution — The Core Operation

The most common sed command is s/old/new/ — substitute "old" with "new":

sed 's/old/new/' file.txt      # replace FIRST "old" on each line
sed 's/old/new/g' file.txt     # replace ALL "old" on each line (g = global)
sed -i 's/foo/bar/g' file.txt  # actually MODIFY the file (-i = in-place)

Deleting and Printing Lines

sed '3d' file.txt              # delete line 3
sed '2,5d' file.txt            # delete lines 2 through 5
sed '/pattern/d' file.txt     # delete lines containing "pattern"
sed -n '3p' file.txt           # print ONLY line 3 (-n suppresses all other output)
sed -n '2,4p' file.txt         # print only lines 2 to 4
sed 's/[0-9]//g' file.txt     # remove all digits (replace each digit with nothing)

awk — THE Most Important FA Round 2 Topic (15 marks)

Why does awk exist? Imagine you have a CSV file with 10,000 employee records. You need to find everyone in the "Sales" department earning over 50,000 and calculate their average salary. In Java, that's 20+ lines of code (open file, read line by line, split by comma, check conditions...). In awk, it's ONE line. awk was built specifically for this kind of "look at data in columns, filter and calculate" work.

Think of awk as a spreadsheet that runs in the terminal. It reads your file row by row, automatically splits each row into columns ($1, $2, $3...), and lets you filter rows, do math, and print results — all in a single command. It's grep (search) + cut (columns) + a calculator, all rolled into one.

Basic Syntax

# awk 'pattern {action}' file
# If pattern matches → action runs. If no pattern → runs on every line.

awk '{print}' file.txt            # print every line (like cat)
awk '{print $0}' file.txt          # same — $0 = entire line
awk '{print $1}' file.txt          # print 1st column only
awk '{print $1, $3}' file.txt     # print 1st and 3rd columns
awk '{print $NF}' file.txt         # print LAST column (NF = number of fields)

Field Variables — Memorize These

Field Separator (-F flag)

# Default separator is space/tab. Use -F to change it.

awk -F':' '{print $1}' /etc/passwd   # colon-separated (like /etc/passwd)
awk -F',' '{print $1,$2}' data.csv   # comma-separated (CSV file)
awk -F'\t' '{print $2}' file.tsv    # tab-separated
awk -F'|' '{print $3}' file.txt     # pipe-separated

Pattern Matching — Filter Lines

# Only process lines that match a condition

awk '/pattern/ {print}' file.txt        # lines containing "pattern"
awk '$3 > 50000 {print $1, $3}' emp.txt # salary (col3) > 50000
awk '$2 == "IT" {print $1}' emp.txt      # department (col2) is IT
awk 'NR >= 2 {print}' file.txt           # skip header (line 1), print rest
awk 'NR == 3 {print}' file.txt           # print only line 3
awk '$1 != "Name" {print}' file.txt     # skip lines where col1 is "Name"
awk '$3 > 30000 && $2 == "HR"' emp.txt  # multiple conditions with &&
awk '$3 > 30000 || $2 == "HR"' emp.txt  # OR condition

BEGIN and END Blocks

# BEGIN runs BEFORE processing any lines
# END runs AFTER processing all lines

awk 'BEGIN {print "=== Report ==="} {print $0} END {print "=== Done ==="}' file.txt

# Calculate total salary
awk 'BEGIN {total=0} {total += $3} END {print "Total:", total}' emp.txt

# Count lines
awk 'END {print NR, "lines"}' file.txt

# Calculate average salary
awk 'BEGIN {sum=0; count=0} {sum += $3; count++} END {print "Avg:", sum/count}' emp.txt

FA Exam Pattern: Employee Table Questions

Assume this file emp.txt (space-separated):

Name    Dept    Salary
Darshan IT      45000
Rahul   HR      38000
Priya   IT      52000
Amit    Finance 41000
Sneha   HR      47000
Kiran   IT      55000

Q1: Print all employee names and salaries

awk 'NR > 1 {print $1, $3}' emp.txt
# NR > 1 skips the header row
# Output: Darshan 45000, Rahul 38000, ...

Q2: Print employees in IT department

awk '$2 == "IT" {print $1, $3}' emp.txt
# Output: Darshan 45000, Priya 52000, Kiran 55000

Q3: Find the maximum salary

awk 'NR > 1 {if ($3 > max) {max = $3; name = $1}} END {print name, max}' emp.txt
# Output: Kiran 55000

Q4: Find the minimum salary

awk 'NR == 2 {min = $3; name = $1} NR > 2 {if ($3 < min) {min = $3; name = $1}} END {print name, min}' emp.txt
# Initialize min with first data row (NR==2), then compare rest
# Output: Rahul 38000

Q5: Calculate total salary

awk 'NR > 1 {total += $3} END {print "Total:", total}' emp.txt
# Output: Total: 278000

Q6: Calculate average salary

awk 'NR > 1 {sum += $3; count++} END {print "Average:", sum/count}' emp.txt
# Output: Average: 46333.3

Q7: Count employees per department

awk 'NR > 1 {dept[$2]++} END {for (d in dept) print d, dept[d]}' emp.txt
# Output: IT 3, HR 2, Finance 1
# dept[$2]++ creates an associative array (like a HashMap) counting by department

Q8: Print employees with salary above average

# Two-pass approach: first calculate average, then filter
awk 'NR > 1 {sum += $3; count++; names[NR]=$1; sals[NR]=$3} END {avg=sum/count; for (i in names) if (sals[i] > avg) print names[i], sals[i]}' emp.txt

Q9: Print employees sorted by salary (with sort pipe)

awk 'NR > 1 {print $3, $1}' emp.txt | sort -n
# Output: 38000 Rahul, 41000 Amit, 45000 Darshan, ...

Q10: Department-wise total salary

awk 'NR > 1 {dept[$2] += $3} END {for (d in dept) print d, dept[d]}' emp.txt
# Output: IT 152000, HR 85000, Finance 41000

awk with printf — Formatted Output

# printf gives formatted output (like C's printf)
awk 'NR > 1 {printf "%-10s %-8s %d\n", $1, $2, $3}' emp.txt
# %-10s = left-aligned string, 10 chars wide
# %d = integer, %f = float, %s = string
# \n = newline (printf doesn't add one automatically)

# Print salary with 2 decimal places
awk 'NR > 1 {printf "%s: %.2f\n", $1, $3}' emp.txt

awk — if/else and Loops

# if/else inside awk
awk 'NR > 1 {if ($3 > 45000) print $1, "HIGH"; else print $1, "LOW"}' emp.txt

# Ternary operator
awk 'NR > 1 {print $1, ($3 > 45000 ? "HIGH" : "LOW")}' emp.txt

# for loop — print each field on a line
awk '{for (i = 1; i <= NF; i++) print $i}' file.txt

awk with Pipes — Combining Commands

# awk works beautifully with pipes

# Find top 3 salaries
awk 'NR > 1 {print $3, $1}' emp.txt | sort -rn | head -3

# Count unique departments
awk 'NR > 1 {print $2}' emp.txt | sort -u | wc -l

# grep + awk combo — find IT employees and their salaries
grep "IT" emp.txt | awk '{print $1, $3}'

# Process command output
ls -l | awk '{print $9, $5}'  # filename and size from ls -l
df -h | awk 'NR > 1 {print $1, $5}'  # disk usage %

Quick Reference — awk Cheat Sheet

Shell Scripting Basics

Why write shell scripts? You've been typing commands one at a time. But what if you need to run the same 10 commands every morning? Or automate a backup every night? A shell script is just a text file full of commands that run automatically, one after another. It's like recording a macro in Excel — write the steps once, run them whenever you want.

Think of a shell script as a recipe card. The recipe lists steps in order. When you "run" the recipe (execute the script), the kitchen (the shell) follows each step from top to bottom.

The Shebang — Every Script Starts Here

The very first line of every shell script must be:

#!/bin/bash

This is called the shebang (or hashbang). It tells the OS: "Use the bash shell to run this script." Without it, the system might not know how to interpret your file. It's like writing "Language: English" at the top of a document — so the reader knows how to read it.

Variables — Storing Values

Variables in bash are simple but have one critical gotcha:

# CORRECT — no spaces around =
NAME="Darshan"
echo "Hello $NAME"    # prints: Hello Darshan

# WRONG — spaces around = causes an error!
# NAME = "Darshan"     ← this FAILS. Bash thinks NAME is a command.

# Read user input
read -p "Enter name: " USERNAME
echo "You entered: $USERNAME"

if-then-else — Making Decisions

Bash's if-else looks different from Java/Python. The structure is: if [ condition ]; then ... elif ... else ... fi. Note: fi is "if" spelled backwards — it closes the if block.

if [ $AGE -gt 18 ]; then
    echo "Adult"
elif [ $AGE -eq 18 ]; then
    echo "Just 18"
else
    echo "Minor"
fi

Loops — Repeating Actions

# for loop — iterate over a list
for i in 1 2 3 4 5; do
    echo "$i"
done

# while loop — repeat while condition is true
COUNT=1
while [ $COUNT -le 5 ]; do
    echo "$COUNT"
    COUNT=$((COUNT + 1))   # $(( )) does arithmetic in bash
done

case Statement — The Switch of Bash

Like Java's switch. Pattern matches a value and runs the matching block. ;; is like break. *) is the default case.

case $1 in
    start)  echo "Starting..." ;;
    stop)   echo "Stopping..." ;;
    *)      echo "Usage: $0 {start|stop}" ;;
esac

esac is "case" spelled backwards — it closes the case block. (fi closes if, esac closes case.)

Comparison Operators

Bash uses different operators for numbers vs. strings. This is a common exam trap.

File Test Operators

These check properties of files. Incredibly useful in scripts — "does this file exist before I try to read it?"

if [ -f "data.csv" ]; then
    echo "Processing data..."
    awk -F',' 'NR > 1 {sum += $3} END {print sum}' data.csv
else
    echo "Error: data.csv not found!"
fi

Special Path Symbols

These are shortcuts for navigating the file system. Think of them as bookmarks:

crontab — Scheduling

Why? You wrote a backup script. Great. Now who runs it at 2 AM every night? You're not setting an alarm to wake up and type the command. crontab is the alarm clock of Unix — it runs commands automatically on a schedule, whether you're asleep, on vacation, or doing anything else.

The format has 5 time fields followed by the command to run:

# ┌───── minute (0-59)
# │ ┌───── hour (0-23)
# │ │ ┌───── day of month (1-31)
# │ │ │ ┌───── month (1-12)
# │ │ │ │ ┌───── day of week (0-6, 0=Sunday)
# │ │ │ │ │
# * * * * * command

0 2 * * * /home/darshan/backup.sh    # 2:00 AM, every day
*/5 * * * * /scripts/check.sh        # every 5 minutes
0 9 * * 1 /scripts/weekly.sh         # 9:00 AM every Monday (1=Monday)
30 18 1 * * /scripts/monthly.sh      # 6:30 PM on the 1st of every month

Practice Questions — Unix

Real FA Subjective Question — Walkthrough

This is an actual FA Round 2 practice question from HackerRank.

Solution:

awk -F"," '
BEGIN { total = 0; found = 0 }
NR > 1 && tolower($3) == "sales" {      # skip header, case-insensitive match
    total += $4;                           # $4 = Salary column
    found = 1
}
END {
    if (found)
        print "Total Salary = " total      # exact format from problem
    else
        print "No Employee Found"          # exact fallback message
}
' $1                                     # $1 = filename from command-line