Development & Scripting – Linux Teaching Plan

1. git – Version Control

git init myrepo
cd myrepo
echo "Hello, Git!" > hello.txt
git add hello.txt
git commit -m "Initial commit"
git remote add origin https://github.com/you/myrepo.git
git push -u origin master

• Clone an existing public repo: git clone https://github.com/git/git.git.
• Make a change, commit, and push to your fork.

2. bash – Script Automation

#!/usr/bin/env bash
# backup.sh – simple backup of a directory
SRC="/home/you/project"
DEST="/tmp/project-backup-$(date +%F).tar.gz"
tar -czf "$DEST" "$SRC"
echo "Backup created at $DEST"

• Make the script executable: chmod +x backup.sh.
• Run it and verify the archive appears in /tmp.

3. python & pip – Package Management

python3 -m venv venv
source venv/bin/activate
pip install requests
python -c "import requests, sys; print(requests.get('https://api.github.com').status_code)"

• Create a requirements.txt with flask and jinja2 and install it with pip install -r requirements.txt.
• Freeze the environment: pip freeze > pinned.txt.

4. node & npm – JavaScript Runtime

npm init -y
npm install express
node -e "const express=require('express');const app=express();app.get('/',(req,res)=>res.send('Hello!'));app.listen(3000,()=>console.log('Listening 3000'))"

• Write an app.js that serves static files from a public directory.
• Run the server and access http://localhost:3000 from a browser.

5. gcc & make – C Build Tools

# hello.c
#include <stdio.h>
int main(){ printf("Hello from C!\n"); return 0; }

# Makefile
CC=gcc
CFLAGS=-Wall -O2
TARGET=hello

all: $(TARGET)

$(TARGET): hello.c
    $(CC) $(CFLAGS) -o $(TARGET) hello.c

clean:
    rm -f $(TARGET)

• Run make to build the binary.
• Execute ./hello and capture its output.

6. cmake – Modern Build System

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(Hello C)
add_executable(hello hello.c)

• Create a build directory: mkdir build && cd build.
• Configure and compile: cmake .. && make.
• Run ./hello and verify the output.

7. sed – Stream Editor

# Replace "foo" with "bar" in file.txt
sed -i 's/foo/bar/g' file.txt

# Show only lines containing "error"
sed -n '/error/p' logfile.txt

• Create a sample file with several occurrences of the word foo and run the replacement command.
• Use sed to delete the 3rd line of a file.

8. awk – Pattern Scanning

# Sum the 3rd column in a CSV
awk -F',' '{sum+=$3} END{print sum}' data.csv

# Print the 1st and 3rd fields of lines that contain "PASS"
awk '$0 ~ /PASS/ {print $1, $3}' results.txt

• Generate a CSV with three numeric columns and use awk to compute the average of the 2nd column.
• Print all lines from passwd where the UID is greater than 1000.

9. vim – Powerful Text Editor

# Basic vim workflow
vim file.txt   # enter normal mode
i              # insert mode
...edit...
Esc            # back to normal
:wq            # write & quit

# Example of searching
/keyword
n  # next match

• Open /etc/passwd in vim and navigate to the line containing root.
• Use a substitution to replace all instances of root with admin (just in the buffer, don’t write yet).

10. tmux – Terminal Multiplexer

# Start a new session
tmux new -s dev

# Split horizontally
Ctrl+b %
# Split vertically
Ctrl+b "

# Switch panes
Ctrl+b o

# Detach
Ctrl+b d

# List sessions
tmux ls
# Attach to session
tmux attach -t dev

• Open a tmux session, create two panes, run top in one and watch -n1 date in the other.
• Detach and reattach to the session from a different terminal.

11. grep – Pattern Matching

# Find all files containing "TODO"
grep -rl "TODO" .

# Show only the matching part
grep -o "error:.*" syslog.log

# Recursive search case‑insensitive
grep -ri "fatal" .

• Search for all Python files that contain the string def main.
• Display the line numbers for matches in makefile.

12. find – File Discovery

# Find all .log files modified in last 7 days
find . -name "*.log" -mtime -7

# Delete all .tmp files
find /tmp -type f -name "*.tmp" -delete

# Execute a command on each file
find . -name "*.py" -exec pyflakes {} +

• List all files larger than 10 MB in /var/log.
• Rename all *.bak files by removing the extension.

13. curl – HTTP Client

# GET request
curl https://api.github.com/repos/torvalds/linux

# POST with JSON payload
curl -X POST https://httpbin.org/post \
     -H "Content-Type: application/json" \
     -d '{"name":"dev","role":"engineer"}'

• Download the latest Ubuntu ISO with a single curl command.
• Use curl -L -o to follow redirects.

14. jq – JSON Processor

# Extract all tag names from GitHub releases
curl https://api.github.com/repos/nodejs/node/releases \
  | jq '.[].tag_name'

# Pretty‑print and filter
cat data.json | jq '.[] | select(.active==true) | .name'

• From a local config.json, extract the value of database.host.
• Count how many objects in an array have a property enabled set to true.

Mini‑Project: Static Site Generator (Bash)

Students will combine at least 5 of the commands above to build a tiny static site generator that:

1. Creates a site directory.
2. Copies a template.html into site/index.html.
3. Accepts markdown files from posts/, converts them to HTML using pandoc (installed via apt or brew).
4. Uses sed to replace a placeholder (e.g., {{content}}) with the rendered HTML.
5. Writes a build.sh script that orchestrates all steps and can be run with ./build.sh.
6. Shows output in a git commit and pushes the final site/ to a GitHub Pages repo.

Deliverables: build.sh, README.md explaining the pipeline, and a live site served via python3 -m http.server.

Assessment & Wrap‑up

1. Quiz (5 questions) – 3‑choice multiple choice covering Git, make, grep, sed, and curl.
2. Hands‑on Task – Students run a script that uses git, grep, and awk to produce a report of all TODO comments in the repo.
3. Project Review – In pairs, students present their static site generator, explain their choice of commands, and demonstrate a successful build.

Score sheet (out of 30 points):