Tools on Software Engineering Learning Paths

Git

Mon, 01 Jan 0001 00:00:00 +0000

What Is Git?#

Git is a distributed version control system that tracks changes in source code. Created by Linus Torvalds in 2005 for Linux kernel development, it’s now the universal standard for software collaboration.

Why Git?#

Feature	Benefit
Distributed	Every clone is a full repository — work offline, no single point of failure
Branching	Create, merge, and delete branches instantly
Speed	Local operations (log, diff, commit) are near-instant
Integrity	Every object is checksummed with SHA-1/SHA-256
Staging area	Fine-grained control over what goes into each commit

Core Concepts#

flowchart LR
 WD["Working Directory"] -->|"git add"| SA["Staging Area<br/>(Index)"]
 SA -->|"git commit"| LR["Local Repository<br/>(.git)"]
 LR -->|"git push"| RR["Remote Repository"]
 RR -->|"git pull / fetch"| LR
 LR -->|"git checkout"| WD

The Three States#

Every file in a Git repository is in one of three states:

Docker and Docker Compose

Mon, 01 Jan 0001 00:00:00 +0000

What Is Docker?#

Docker is a platform for building, running, and distributing applications inside containers — lightweight, isolated environments that package code with all its dependencies. Containers share the host OS kernel, making them far more efficient than virtual machines.

flowchart TB
 subgraph VM["Virtual Machine"]
 GA["Guest OS A"]
 AA["App A + Libs"]
 GA --- AA
 end
 subgraph VM2["Virtual Machine"]
 GB["Guest OS B"]
 AB["App B + Libs"]
 GB --- AB
 end
 subgraph Container["Containers"]
 CA["App A + Libs"]
 CB["App B + Libs"]
 end
 
 HV["Hypervisor"]
 DR["Docker Engine"]
 HOST["Host OS + Kernel"]
 HW["Hardware"]
 
 VM --- HV
 VM2 --- HV
 Container --- DR
 HV --- HOST
 DR --- HOST
 HOST --- HW

Containers vs Virtual Machines#

Aspect	Container	Virtual Machine
Boot time	Seconds	Minutes
Size	MBs (app + libs only)	GBs (full OS)
Isolation	Process-level (shared kernel)	Full hardware-level
Performance	Near-native	Hypervisor overhead
Density	Hundreds per host	Tens per host
Use case	Microservices, CI/CD, dev environments	Full OS isolation, legacy apps

Core Concepts#

Concept	What It Is
Image	Read-only template with app code, runtime, libraries, and config. Blueprint for containers.
Container	Running instance of an image. Isolated process with its own filesystem, networking, PID space.
Dockerfile	Text file with instructions to build an image layer by layer.
Registry	Storage for images (Docker Hub, ECR, GCR, GitLab Registry).
Volume	Persistent storage that survives container restarts/removal.
Network	Virtual network connecting containers.

Essential Commands#

Images#

# Pull from registry
docker pull nginx:1.25
docker pull python:3.12-slim

# List local images
docker images
docker image ls

# Build from Dockerfile
docker build -t myapp:1.0 .
docker build -t myapp:latest -f Dockerfile.prod .

# Remove
docker rmi nginx:1.25
docker image prune # Remove dangling images
docker image prune -a # Remove all unused images

Containers#

# Run (create + start)
docker run nginx # Foreground
docker run -d nginx # Detached (background)
docker run -d -p 8080:80 nginx # Map host:container port
docker run -d --name web -p 8080:80 nginx # Named container
docker run --rm alpine echo "hello" # Remove after exit

# Interactive shell
docker run -it ubuntu bash
docker exec -it web bash # Shell into running container

# Lifecycle
docker start web
docker stop web
docker restart web
docker rm web # Remove stopped container
docker rm -f web # Force remove (running)

# Inspect
docker ps # Running containers
docker ps -a # All (including stopped)
docker logs web # View logs
docker logs -f web # Follow logs
docker inspect web # Full JSON details
docker stats # Live resource usage

Volumes#

# Named volume (managed by Docker)
docker volume create mydata
docker run -d -v mydata:/app/data myapp

# Bind mount (host path)
docker run -d -v $(pwd)/src:/app/src myapp

# List and clean
docker volume ls
docker volume prune

Dockerfile#

Anatomy#

# Base image
FROM python:3.12-slim

# Metadata
LABEL maintainer="you@example.com"

# Set working directory
WORKDIR /app

# Install dependencies (cached layer)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY src/ ./src/

# Environment variables
ENV ENVIRONMENT=production
ENV PORT=8000

# Expose port (documentation)
EXPOSE 8000

# Non-root user (security)
RUN useradd -r appuser
USER appuser

# Default command
CMD ["python", "-m", "uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]

Key Instructions#

Instruction	Purpose
`FROM`	Base image (always first)
`WORKDIR`	Set working directory for subsequent instructions
`COPY`	Copy files from build context into image
`ADD`	Like COPY but can extract tarballs and fetch URLs
`RUN`	Execute command during build (creates layer)
`ENV`	Set environment variable
`EXPOSE`	Document which port the container listens on
`USER`	Switch to non-root user
`CMD`	Default command when container starts (overridable)
`ENTRYPOINT`	Fixed command (CMD becomes arguments)
`ARG`	Build-time variable (not available at runtime)
`VOLUME`	Declare mount point
`HEALTHCHECK`	Define health check command

Multi-Stage Builds#

Produce small production images by separating build from runtime:

SSH

Mon, 01 Jan 0001 00:00:00 +0000

What Is SSH?#

SSH (Secure Shell) is a cryptographic network protocol for secure communication between computers over an unsecured network. It provides encrypted remote login, command execution, file transfer, and port forwarding.

SSH replaced insecure predecessors like Telnet, rlogin, and FTP — which transmitted everything (including passwords) in plaintext.

What SSH Provides#

Feature	Description
Authentication	Verify identity (password or key-based)
Encryption	All traffic encrypted in transit (AES, ChaCha20)
Integrity	Detect tampering (HMAC)
Tunneling	Forward ports, proxy traffic through encrypted channel
File transfer	SCP and SFTP for secure file operations

How SSH Works#

sequenceDiagram
 participant Client
 participant Server
 
 Client->>Server: TCP connection (port 22)
 Client->>Server: Protocol version exchange
 Server->>Client: Protocol version exchange
 Note over Client,Server: Key exchange (Diffie-Hellman)
 Note over Client,Server: Session encryption established
 Client->>Server: Authentication (key or password)
 Server->>Client: Authentication success
 Note over Client,Server: Encrypted session active

Authentication Methods#

Method	Security	Use Case
Public key	Excellent	Default for servers, CI/CD, automation
Password	Moderate	Quick setup, less secure
Certificate	Excellent	Enterprise, large fleet management
GSSAPI/Kerberos	Excellent	Corporate environments with AD

Key-Based Authentication#

Generating Keys#

# Ed25519 (recommended — fast, secure, short keys)
ssh-keygen -t ed25519 -C "you@example.com"

# RSA (legacy compatibility — use 4096 bits minimum)
ssh-keygen -t rsa -b 4096 -C "you@example.com"

# With custom filename
ssh-keygen -t ed25519 -f ~/.ssh/id_work -C "work laptop"

This creates two files:

Apache HTTP Server

Mon, 01 Jan 0001 00:00:00 +0000

What Is Apache?#

Apache HTTP Server (commonly “Apache” or “httpd”) is the world’s most widely-used web server, maintained by the Apache Software Foundation since 1995. It serves static and dynamic content via a modular architecture with support for virtual hosts, URL rewriting, authentication, proxying, and more.

Apache vs Nginx#

Aspect	Apache	Nginx
Architecture	Process/thread per connection	Event-driven, async
Config style	`.htaccess` per-directory (flexible)	Centralized config (performant)
Dynamic content	`mod_php`, `mod_python` (in-process)	Proxies to external process (PHP-FPM)
Best for	Shared hosting, `.htaccess` flexibility	High concurrency, reverse proxying
Performance (static)	Good	Excellent
Performance (dynamic)	Excellent (mod_php)	Excellent (via proxy)

Installation#

# Debian/Ubuntu
sudo apt update && sudo apt install apache2

# RHEL/CentOS/Amazon Linux
sudo yum install httpd # or: sudo dnf install httpd

# macOS (built-in, or via Homebrew)
brew install httpd

# Start and enable
sudo systemctl start apache2 # Debian
sudo systemctl start httpd # RHEL
sudo systemctl enable apache2

Directory Structure#

Debian/Ubuntu#

/etc/apache2/
├── apache2.conf # Main config
├── ports.conf # Listen directives
├── sites-available/ # Virtual host configs (inactive)
├── sites-enabled/ # Symlinks to active vhosts
├── mods-available/ # Available modules
├── mods-enabled/ # Active modules (symlinks)
├── conf-available/ # Additional config fragments
└── conf-enabled/ # Active config fragments

RHEL/CentOS#

/etc/httpd/
├── conf/httpd.conf # Main config
├── conf.d/ # Additional configs (*.conf auto-loaded)
└── modules/ # Module .so files

Content and Logs#

/var/www/html/ # Default document root
/var/log/apache2/ # Debian logs
/var/log/httpd/ # RHEL logs

Virtual Hosts#

Virtual hosts let one Apache instance serve multiple websites:

Nginx

Mon, 01 Jan 0001 00:00:00 +0000

What Is Nginx?#

Nginx (pronounced “engine-x”) is a high-performance web server, reverse proxy, and load balancer. Created by Igor Sysoev in 2004 to solve the C10K problem (handling 10,000+ concurrent connections), it uses an event-driven, asynchronous architecture that excels at serving static content and proxying to application backends.

Architecture#

flowchart TB
 CLIENTS["Clients<br/>(thousands of connections)"]
 MASTER["Master Process<br/>(reads config, manages workers)"]
 W1["Worker Process 1<br/>(event loop)"]
 W2["Worker Process 2<br/>(event loop)"]
 W3["Worker Process N<br/>(event loop)"]
 
 CLIENTS --> MASTER
 MASTER --> W1
 MASTER --> W2
 MASTER --> W3

Each worker process handles thousands of connections in a single thread using non-blocking I/O (epoll/kqueue). No thread-per-connection overhead.

Package Management

Mon, 01 Jan 0001 00:00:00 +0000

What Is Package Management?#

A package manager automates the process of installing, upgrading, configuring, and removing software. Instead of downloading binaries from websites and managing dependencies manually, you use a command-line tool that handles everything — fetching packages from repositories, resolving dependency trees, and tracking what’s installed.

Why Package Managers Matter#

Without	With
Download from random websites	Install from trusted repositories
Manual dependency hunting	Automatic dependency resolution
No easy way to update all software	Single command to update everything
Unknown security status	Signed packages, vulnerability tracking
Difficult to reproduce environments	Scriptable, reproducible installs

Chocolatey (Windows)#

Chocolatey is the leading package manager for Windows, bringing Linux-style package management to the Windows ecosystem.

Containers in Production

Mon, 01 Jan 0001 00:00:00 +0000

Beyond `docker run`#

Running a container locally is one thing. Running dozens — or thousands — of containers reliably in production requires orchestration, security hardening, observability, and disciplined image management. This section bridges the gap between local Docker usage and production-grade container infrastructure.

Container Orchestration Concepts#

Why Orchestrate?#

A single container on a single host has no resilience. If it crashes, nothing restarts it. If traffic spikes, nothing scales it. Orchestration solves these problems:

Tools on Software Engineering Learning Paths

Git

What Is Git?#

Why Git?#

Core Concepts#

The Three States#

Docker and Docker Compose

What Is Docker?#

Containers vs Virtual Machines#

Core Concepts#

Essential Commands#

Images#

Containers#

Volumes#

Dockerfile#

Anatomy#

Key Instructions#

Multi-Stage Builds#

SSH

What Is SSH?#

What SSH Provides#

How SSH Works#

Authentication Methods#

Key-Based Authentication#

Generating Keys#

Apache HTTP Server

What Is Apache?#

Apache vs Nginx#

Installation#

Directory Structure#

Debian/Ubuntu#

RHEL/CentOS#

Content and Logs#

Virtual Hosts#

Nginx

What Is Nginx?#

Architecture#

Package Management

What Is Package Management?#

Why Package Managers Matter#

Chocolatey (Windows)#

Containers in Production

Beyond docker run#

Container Orchestration Concepts#

Why Orchestrate?#

Beyond `docker run`#