Mohammad Abu Mattar | Cheatsheets

Python Virtual Environments Cheatsheet

Mohammad Abu Mattar — Mon, 17 Aug 2026 13:43:57 GMT

A fast reference for keeping Python projects isolated and reproducible. It covers creating and activating environments with venv, installing packages with pip, locking dependencies with requirements files and pip-tools, switching interpreter versions with pyenv, and installing global CLI tools cleanly with pipx.

GitHub Actions

Mohammad Abu Mattar — Tue, 04 Aug 2026 15:27:06 GMT

GitHub Actions runs your CI/CD directly from YAML files in .github/workflows/, and most of the job is knowing which key does what. A workflow reacts to events, splits into jobs that run on runners, and each job is an ordered list of steps that either call a reusable action or run a shell command.

This cheatsheet walks the parts you touch on every pipeline: triggers that decide when things run, the job and step structure, env and secrets across their three scopes, matrix builds for testing many versions at once, caching and artifacts to stay fast, and reusable workflows and composite actions to stop copy-pasting the same YAML into every repo.

Key features

Trigger precisely: filter push and pull_request by branch and path, plus schedule and workflow_dispatch.
Structure jobs: needs for ordering, if for conditions, runs-on for the machine.
Handle secrets safely: three env scopes, masked secrets, and a least-privilege GITHUB_TOKEN.
Scale and reuse: matrix builds, dependency caching, artifacts, reusable workflows, and composite actions.

Linux Networking

Mohammad Abu Mattar — Tue, 21 Jul 2026 15:07:31 GMT

Every Linux box speaks the network through a small set of tools, and knowing them turns "the network is broken" into a specific, fixable answer. This cheatsheet covers the modern stack: ip for interfaces and routes, ss for sockets, dig for DNS, traceroute for the path, tcpdump for the raw packets, and curl for the application layer.

When something won't connect, work up the layers. Confirm the interface has an address and a route (ip), check the port is listening (ss), make sure the name resolves (dig), trace where packets die (traceroute), and only then capture the wire (tcpdump) or test the app (curl).

Key features

One tool per layer: ip for L2/L3, ss for sockets, dig for DNS, tcpdump for packets, curl for HTTP.
Modern replacements: ip supersedes ifconfig/route, and ss supersedes netstat.
Ground truth on demand: tcpdump shows the actual bytes when higher-level tools disagree.
Scriptable diagnostics: dig +short and curl -w give clean, parseable output for automation.

kubectl

Mohammad Abu Mattar — Wed, 27 May 2026 00:00:00 GMT

kubectl is the command-line tool you use to talk to a Kubernetes cluster. Whatever you can do through a dashboard, you can do faster here: deploy apps, inspect resources, stream logs, run commands inside containers, and take nodes in and out of service.

The mental model is simple. You tell kubectl a verb and a resource (get pods, delete deployment, apply -f file.yaml), it talks to the cluster's API server, and the cluster does the work. Get comfortable with get, describe, logs, and apply and you're already most of the way there.

Key features

One tool for everything: deploy, inspect, update, scale, and debug from a single CLI.
Declarative or imperative: apply YAML you keep in Git, or fire off quick one-off commands.
Flexible output: reshape any command into wide tables, JSON, YAML, JSONPath, or custom columns for scripting.
Built-in debugging: stream logs, exec into containers, attach ephemeral debug containers, and forward ports to your laptop.

Terraform Cheatsheet

Mohammad Abu Mattar — Sat, 28 Mar 2026 20:02:59 GMT

A practical cheatsheet covering the Terraform CLI commands engineers reach for constantly: init, plan, apply, import, taint, and state operations. It also covers the key HCL patterns for variables, locals, outputs, and dynamic blocks.

The sections below cover Terraform commands, syntax, and examples.

AWS CLI

Mohammad Abu Mattar — Wed, 25 Mar 2026 00:00:00 GMT

The AWS Command Line Interface (CLI) lets you orchestrate infrastructure, move cloud data, and configure security entirely from the terminal. This reference covers configuring identity profiles, managing EC2 instances, synchronizing S3 buckets, creating IAM roles, querying nested JSON with JMESPath, formatting output, and securing access with Systems Manager.

Later sections add pagination and waiters, STS cross-account access, CloudWatch Logs, Lambda, Secrets Manager and Parameter Store, and ECR with ECS deployments.

Docker Swarm

Mohammad Abu Mattar — Sat, 07 Mar 2026 00:00:00 GMT

This cheatsheet is a reference for managing Docker Swarm clusters, services, and stacks. It covers the commands and best practices for scaling, updating, and monitoring your swarm applications.

Ansible

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

Ansible is an automation tool for configuration management, application deployment, and orchestration. This cheatsheet is a quick reference for common Ansible tasks, modules, and best practices.

Chef

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

Chef is an Infrastructure as Code platform for automating infrastructure configuration, deployment, and management. This cheatsheet covers Chef concepts, commands, patterns, and best practices for managing infrastructure with Chef Infra, Chef Server, and related tools.

Docker Compose

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

Docker Compose is a tool for defining and running multi-container Docker applications. It uses a YAML file to configure application services, networks, and volumes. This cheatsheet provides a quick reference for common Docker Compose commands, configuration options, best practices, and troubleshooting tips.

Dockerfile

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

This cheat sheet covers the core Dockerfile instructions, best practices, and common pitfalls for building small, secure Docker images. Each section pairs a Dockerfile snippet with the build output it produces, plus notes on how the instruction behaves.

PostgreSQL

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

PostgreSQL reference guide covering psql commands, database creation, tables, queries, functions, joins, transactions, indexes, and advanced SQL operations.

Redis

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

Redis reference guide covering commands, data types, keys, strings, lists, sets, hashes, sorted sets, transactions, pub/sub, and caching strategies.

SSH

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

export const components = { h1: 'h1', h2: 'h2', h3: 'h3', h4: 'h4', h5: 'h5', h6: 'h6', p: 'p', a: 'a', ul: 'ul', ol: 'ol', li: 'li', code: 'code', pre: 'pre', strong: 'strong', em: 'em', blockquote: 'blockquote', table: 'table', th: 'th', tr: 'tr', td: 'td', };

VS Code

Mohammad Abu Mattar — Sat, 28 Feb 2026 00:00:00 GMT

Complete VS Code keyboard shortcuts reference including command palette, navigation, editing, debugging, multicursor operations, and advanced features for macOS and Windows/Linux

AWK

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

AWK complete reference guide

Quick start

# Print entire file
awk '{ print }' file.txt

# Print specific column
awk '{ print $1 }' file.txt

# Print lines matching pattern
awk '/pattern/ { print }' file.txt

# Sum all numbers in first column
awk '{ sum += $1 } END { print sum }' numbers.txt

# Replace text pattern
awk '{ gsub(/old/, "new"); print }' file.txt

AWK program structure

awk '[BEGIN block] [pattern { action }] [END block]' [options] [file]

Essential built-in variables

Variable	Description
NR	Total record number (line)
FNR	File record number
NF	Number of fields
FS	Field separator (input)
OFS	Output field separator
RS	Record separator
ORS	Output record separator
FILENAME	Current filename
ARGC	Argument count
ARGV	Argument array
ENVIRON	Environment variables
RSTART	Start of match (from match())
RLENGTH	Length of match

Field variables

$0     # Entire line
$1     # First field
$2     # Second field
$NF    # Last field
$(NF-1) # Second-to-last field

String functions reference

length(str)           # String length
substr(str, s, l)     # Substring (start, length)
index(str, substr)    # Find substring position
split(str, arr, sep)  # Split string into array
sub(regex, repl)      # Replace first match
gsub(regex, repl)     # Replace all matches
match(str, regex)     # Test match, set RSTART/RLENGTH
tolower(str)          # Convert to lowercase
toupper(str)          # Convert to uppercase
sprintf(fmt, ...)     # Format string

Math functions reference

int(x)        # Integer part
sqrt(x)       # Square root
sin(x)        # Sine (radians)
cos(x)        # Cosine (radians)
atan2(y,x)    # Arctangent
exp(x)        # e^x
log(x)        # Natural logarithm
rand()        # Random 0-1
srand(seed)   # Seed random

Operators quick reference

# Arithmetic: +, -, *, /, %, ^
# Comparison: <, <=, >, >=, ==, !=
# Logical: &&, ||, !
# String: ~ (match), !~ (not match)
# Assignment: =, +=, -=, *=, /=, %=, ^=, ++, --
# Ternary: condition ? true_val : false_val

Command-line options

-F sep         # Set field separator
-v var=val     # Set variable
-f script.awk  # Read program from file
-W version     # Show version
--posix        # POSIX mode

Common one-liners

# Print line numbers
awk '{ print NR, $0 }' file

# Print lines longer than 80 characters
awk 'length($0) > 80 { print }' file

# Print every nth line
awk 'NR % n == 0 { print }' file

# Reverse lines
awk '{ arr[NR] = $0 } END { for (i=NR; i>0; i--) print arr[i] }' file

# Print lines where column 2 > 100
awk '$2 > 100 { print }' file

# Transpose CSV
awk -F',' '{ for(i=1;i<=NF;i++) a[i,NR]=$i } END { for(i=1;i<=NF;i++) { for(j=1;j<=NR;j++) printf "%s%s", a[i,j], (j==NR?"\n":","); print "" } }' file

Tips and best practices

Use single quotes to prevent shell interpretation
Use -F flag to set different field separators
Combine awk with pipes and other tools (grep, sort, uniq)
Save complex programs in .awk files with -f flag
Use printf for formatted output
Initialize variables in BEGIN block
Test on small files before processing large datasets
Use comments (#) to document complex logic
Consider performance with large files (avoid unnecessary loops)

Chmod

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Complete chmod reference covering file permissions, recursive changes with -v and -c, reference mode, logical operators, batch operations, practical examples, and security best practices for Linux file management.

Cron

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Quick reference

Field layout

Min  Hour Day  Month Weekday  Command
 *    *    *    *     *       /path/to/command

 ┬    ┬    ┬    ┬     ┬
 │    │    │    │     └─────  Weekday (0=Sunday, 6=Saturday)
 │    │    │    └──────────  Month (1-12)
 │    │    └───────────────  Day (1-31)
 │    └────────────────────  Hour (0-23)
 └─────────────────────────  Minute (0-59)

Operators

Operator	Name	Example	Description
`*`	Any	`* * * * *`	Every minute
`,`	List	`0,30 * * * *`	Minutes 0 and 30
`-`	Range	`9-17 * * * *`	9 AM to 5 PM
`/`	Step	`/15 * * *`	Every 15 minutes

Special strings

String	Frequency	Equivalent
`@reboot`	Run at startup	N/A
`@hourly`	Every hour	`0 * * * *`
`@daily`	Every day	`0 0 * * *`
`@weekly`	Every week	`0 0 * * 0`
`@monthly`	Every month	`0 0 1 * *`
`@yearly`	Every year	`0 0 1 1 *`

Common patterns

Pattern	Meaning
`0 * * * *`	Every hour
`/15 * * *`	Every 15 minutes
`0 0 * * *`	Daily at midnight
`0 9 * * 1-5`	9 AM on weekdays
`0 0 * * 0`	Sunday at midnight
`0 0 1 * *`	1st of month at midnight

Essential commands

crontab -e              # Edit current user's crontab
crontab -l              # List crontab jobs
crontab -r              # Delete current user's crontab
crontab -u username -e  # Edit user's crontab (root)
crontab -u username -l  # List user's crontab (root)

# System-wide scheduling
ls /etc/cron.{hourly,daily,weekly,monthly}/
cat /etc/crontab

Crontab management

Install from file

crontab /path/to/crontab.txt      # Replace entire crontab
crontab -l > backup.txt           # Backup before changes

System logs

# Debian/Ubuntu
journalctl -u cron -f             # Follow cron logs
grep CRON /var/log/syslog         # Historical logs

# CentOS/RHEL
tail -f /var/log/cron             # Follow cron logs

Environment setup

Always add at top of crontab file:

SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOME=/home/username
LOGNAME=username
MAILTO=admin@example.com

Resources

Official Crontab Manual
Crontab Guru, a visual cron expression explainer
Linux Cron Documentation

Curl

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Getting started with Curl

cURL (client URL) is a command-line tool for transferring data using URLs. It speaks HTTP, HTTPS, FTP, SFTP, and many other protocols, which makes it the usual choice for web development, API testing, and scripting. The common jobs are testing a REST API, downloading a file, and debugging an HTTP connection.

What makes cURL essential

Protocols: HTTP, HTTPS, FTP, FTPS, SCP, SFTP, TELNET, LDAP, LDAPS, and more
Works with any web service or API over those protocols
Scriptable, which makes requests repeatable in automation
Verbose output for diagnosing connection and API issues
No GUI required, and it runs on minimal resources

Common use cases

# Test if an API endpoint is responding
curl https://api.github.com/users/github

# Download files
curl -O https://example.com/file.tar.gz

# POST data to a form
curl -X POST -d "username=user&password=pass" https://example.com/login

# Check API response status
curl -I https://api.example.com/health

# Debug API connections
curl -v https://api.example.com/endpoint

Installation quick reference

macOS: brew install curl Ubuntu/Debian: sudo apt-get install curl CentOS/RHEL: sudo yum install curl Windows: Download from curl.se or choco install curl

Essential options reference

Option	Purpose
`-X GET/POST/PUT/DELETE/PATCH`	Specify HTTP method
`-H "Header: value"`	Add custom header
`-d 'data'`	Send POST data (URL encoded)
`-F "file=@path"`	Upload file (multipart form)
`-u user:pass`	HTTP Basic authentication
`-b "cookie=value"`	Send cookie
`-c cookies.txt`	Save response cookies
`-i`	Include response headers
`-I`	Headers only (HEAD request)
`-L`	Follow redirects
`-v` / `-vv`	Verbose output (debug)
`-s`	Silent mode (no progress)
`-o file.txt`	Save to file
`-O`	Save with original filename
`-w "%{http_code}"`	Custom output format
`-k` / `--insecure`	Skip SSL verification (unsafe)
`--cacert ca.pem`	Use custom CA certificate
`--max-time 10`	Timeout after 10 seconds
`--compressed`	Request compression

HTTP methods quick start

# GET - Retrieve data (default)
curl https://api.example.com/users

# POST - Create resource
curl -X POST -H "Content-Type: application/json" \
  -d '{"name":"John"}' https://api.example.com/users

# PUT - Replace entire resource
curl -X PUT -H "Content-Type: application/json" \
  -d '{"name":"Jane","age":30}' https://api.example.com/users/1

# PATCH - Update specific fields
curl -X PATCH -H "Content-Type: application/json" \
  -d '{"age":31}' https://api.example.com/users/1

# DELETE - Remove resource
curl -X DELETE https://api.example.com/users/1

Workflow examples

Testing a REST API

# 1. Test get all users
curl https://api.example.com/users

# 2. Create a new user
curl -X POST -H "Content-Type: application/json" \
  -d '{"name":"Alice","email":"alice@example.com"}' \
  https://api.example.com/users

# 3. Get specific user
curl https://api.example.com/users/1

# 4. Update user
curl -X PATCH -H "Content-Type: application/json" \
  -d '{"email":"alice.new@example.com"}' \
  https://api.example.com/users/1

# 5. Delete user
curl -X DELETE https://api.example.com/users/1

Authenticated API requests

# Using bearer token
TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
curl -H "Authorization: Bearer $TOKEN" https://api.example.com/protected

# Using API key
API_KEY="sk_live_abc123xyz789"
curl -H "X-API-Key: $API_KEY" https://api.example.com/data

# Using Basic auth
curl -u username:password https://api.example.com/protected

# OAuth2 flow
TOKEN=$(curl -X POST -d "client_id=xxx&client_secret=yyy&grant_type=client_credentials" https://auth.example.com/token | jq -r '.access_token')
curl -H "Authorization: Bearer $TOKEN" https://api.example.com/data

File handling

# Download file
curl -o myfile.txt https://example.com/file.txt

# Upload file
curl -F "file=@myfile.txt" https://api.example.com/upload

# Download and extract
curl -s https://example.com/archive.tar.gz | tar xz

# Resume interrupted download
curl -C - -o largefile.iso https://example.com/largefile.iso

# Upload multiple files
curl -F "files=@file1.txt" -F "files=@file2.txt" https://api.example.com/upload-multiple

Debugging and troubleshooting

# Verbose output (see all request/response details)
curl -v https://api.example.com/data

# More verbose (shows all low-level details)
curl -vv https://api.example.com/data

# Show headers only
curl -i https://api.example.com/data

# Check response time
curl -w "Total time: %{time_total}s\n" https://api.example.com/data

# Save full debug output
curl -v https://api.example.com/data > response.html 2> debug.txt

# Test with custom headers
curl -H "X-Custom: value" -v https://api.example.com/data

Batch processing

# Check multiple endpoints
for url in api1.com api2.com api3.com; do
  echo -n "$url: "
  curl -s -o /dev/null -w "%{http_code}\n" "https://$url"
done

# Process JSON array response
curl -s https://api.example.com/users | jq -r '.[] | .email' | \
  while read email; do
    echo "Processing: $email"
    curl -X POST -H "Content-Type: application/json" \
      -d "{\"email\":\"$email\",\"status\":\"active\"}" \
      https://api.example.com/notify
  done

# Parallel requests
for i in {1..10}; do
  curl -s "https://api.example.com/data/$i" &
done
wait
echo "All requests completed"

Performance tips

Use --compressed for APIs that support gzip/deflate compression
Add timeouts with --max-time and --connect-timeout to prevent hanging
Batch requests with & and wait for parallel execution
Filter responses with jq or grep to reduce processing time
Use HEAD requests (-I) to check whether a resource exists without downloading it

Common patterns

Check if service is up:

curl -f -s -o /dev/null -w "%{http_code}\n" https://api.example.com/health

Loop with retry:

for attempt in {1..3}; do
  curl -f https://api.example.com/data && break
  [ $attempt -lt 3 ] && sleep 2
done

Extract and transform:

curl -s https://api.example.com/users | jq '[.[] | select(.active) | {name, email}]'

Save with authentication:

curl -u user:pass -H "Accept: application/json" https://api.example.com/data > data.json

Best practices

Use HTTPS for authenticated requests
Check exit codes and HTTP status codes
Store tokens and credentials in environment variables, not in scripts
Check JSON syntax and validate responses before processing
Prevent hanging requests with --max-time and --connect-timeout
Redact sensitive data from logs
Test API calls against staging before production use
Comment curl commands to explain what they do and why

curl vs other tools

Tool	Best For
curl	Command-line, scripts, quick testing
wget	Large file downloads, mirroring sites
Postman	Interactive API testing with GUI
HTTPie	More intuitive syntax, pretty output
Python requests	Complex automation and data processing

Getting help

Manual: man curl or curl --help
Online: curl.se docs
Examples: Everything curl book
Common Issues: Check curl troubleshooting guide

Pro Tip: Create a .curlrc file in your home directory to store default options and headers for commonly used APIs. This keeps your commands clean and consistent across multiple requests.

Dart

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Dart is a statically-typed, strongly null-safe programming language designed for building fast, multi-platform applications. Created by Google, Dart ships with its own compiler, formatter, and package manager for web, server, and mobile development.

Language features:

Strong Null Safety: The type system separates nullable from non-nullable types, so null reference errors are caught at compile time.
Async/Await: First-class support for asynchronous programming with futures, streams, and async/await syntax.
Object-Oriented: Full OOP support with classes, inheritance, mixins, and abstract classes.
Generics: A generic type system for reusable, type-safe code.
Extensions: Extend existing types with new methods without inheritance.
Type Inference: Automatic type inference while maintaining strict type safety.
Hot Reload: Rapid development cycle with instant code changes during debugging.

The categories below cover Dart syntax, advanced features, and best practices.

Docker

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Docker is a containerization platform that packages applications with their dependencies into isolated, portable environments called containers. It enables developers to build, ship, and run applications consistently across different systems.

Benefits

Run the same environment in development, test, and production.
Applications are isolated from each other and from the host system.
A containerized application deploys to any system running Docker.
Containers are lighter than virtual machines and start faster.
Scale horizontally by running more containers.

Quick start

Install Docker: Follow the installation guide in the Getting Started section.

Run your first container: docker run -d -p 8080:80 nginx:latest

Access the service: Open http://localhost:8080 in your browser.

Common workflows

Development: Use containers to match production environment locally
Building Images: Create Dockerfiles and build images for your applications
Running Services: Run containers with proper networking and storage configuration
Scaling: Use container orchestration (Docker Swarm or Kubernetes) for production deployments

The sections above cover Docker commands, networking, storage, and best practices for containerized applications.

Find

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Best practices for find command usage

Always quote patterns to prevent shell expansion of special characters
Use -type f first in find expressions for optimal performance
Prune heavy directories early like node_modules, .git, .venv
Use -maxdepth to limit search depth and improve performance
Test commands first with -ls or -printf before using -delete
Use + instead of ; with exec for better performance on many files
Suppress permission errors with 2>/dev/null for cleaner output
Combine multiple criteria to create efficient targeted searches
Use -xdev to skip other filesystems when needed
Consider locate command for quick name-only searches (faster than find)

Common errors and solutions

error: "Permission denied" → Use 2>/dev/null to suppress or run with sudo
error: "No such file or directory" → Verify path exists and is readable
error: "Unexpected operator or missing operand" → Check parentheses are escaped: 
error: "Syntax error near token" → Verify \; or + is present after -exec
error: "Find is too slow" → Use -maxdepth, -prune, and -type filters
error: "Deleted wrong files accidentally" → Always preview with find first!
error: "Pattern not matching expected files" → Test pattern with -ls before -delete
error: "xtype/executable not recognized" → Use newer GNU find; some options are GNU-specific

ref: https://man7.org/linux/man-pages/man1/find.1.html

Git

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Git is a distributed version control system. Developers use it to track code changes, collaborate with teams, and manage project history. Most software teams build their workflow around it.

Key concepts

Distributed: Every developer has a complete copy of the repository history
Branching: Create isolated lines of development for features and fixes
Commits: Snapshots of changes with descriptive messages
Merging: Combine changes from different branches
Tracking: Monitor changes across files and identify who changed what

Common use cases

Collaborative Development: Multiple developers working on same project
Version Control: Track all changes with full history
Branching Strategy: Feature branches, release branches, hotfix branches
Code Review: Pull requests and merge reviews before integration
Rollback Capability: Revert to previous states if needed

Quick reference

Initial Setup: Configure your identity with git config --global user.name and user.email

Start Project: Use git init for new repos or git clone to download existing

Save Work: git add files, then git commit -m "message" to create snapshots

Share Changes: git push to upload, git pull to download updates

The sections above cover Git workflows, starting with everyday commands and ending with rebase, bisect, and repository maintenance.

Go

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Go is a statically typed, compiled programming language designed with simplicity and efficiency in mind. It excels at concurrent programming, which makes it a good fit for fast, scalable server applications and system tools.

The sections below cover Go syntax, functions, concurrency patterns, and best practices.

Grep

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Best practices for grep usage

Always quote patterns to prevent shell interpretation of special characters
Use -E flag for complex patterns to avoid escaping issues with basic regex
Test patterns on sample data before running on production systems
Use -n with debugging to quickly navigate to errors in code
Combine with pipes to build data processing pipelines
Use -F for literal strings when you don't need regex (much faster)
Use -w for word boundaries to avoid partial word matches in code
Use anchors (^ for start, $ for end) to match precise patterns
Exclude directories early with grep -r to improve performance
Use --color=always in pipes to highlight matches in complex pipelines

Common errors and solutions

error: "No such file or directory" → Check file path exists and permissions are correct
error: "grep: (standard input): No such device" → Check input method; the piped input may not be valid
error: "Invalid regular expression" → Check regex syntax; escape special characters or use -F for literals
error: "Binary file matches" → Use -a flag or --binary-files=text to treat as text
error: "Nothing found when expecting matches" → Verify pattern is correct; test pattern syntax with sample data
error: "Searching too slowly" → Use -F for literals, limit results with -m, exclude directories with --exclude-dir

ref: https://man7.org/linux/man-pages/man1/grep.1.html

Helm

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Helm is the package manager for Kubernetes that simplifies the deployment, management, and upgrade of applications. It uses charts, which are templated Kubernetes manifests, to build reusable, configurable application packages.

Benefits

Deploy an entire application stack with a single command.
Share and reuse charts across projects and teams.
Override values without editing templates.
Track revisions and roll back to a previous release.
Include and manage chart dependencies automatically.
Deploy several instances with different configurations.

Quick start

Install Helm: Follow the Installation Setup section.

Add a repository: helm repo add bitnami https://charts.bitnami.com/bitnami

Search for charts: helm search repo nginx

Install a chart: helm install my-web bitnami/nginx --create-namespace

Check status: helm status my-web

Common workflows

First Deploy: Add repository, search chart, install with values
Configuration: Customize with values files and flag overrides
Upgrades: Update releases with new chart versions and configuration changes
Rollback: Revert to previous versions if issues occur
Chart Development: Create custom charts for your applications
Production: Manage multiple environments with versioned, auditable deployments

The sections above cover Helm from basic commands through production deployment practices.

JSON

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

JSON (JavaScript Object Notation) is a lightweight, text-based data exchange format. It's universally supported across programming languages and provides a simple, readable way to structure and transmit data.

Browse the sections below to explore JSON syntax, data types, and practical examples.

Kubernetes

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Kubernetes is the de facto standard for container orchestration. It automates deployment, scaling, and management of containerized applications across clusters of machines. Configuration is declarative, and the control plane restarts failed containers on its own.

Key features

Deploys containers to nodes automatically
Restarts failed containers and replaces unhealthy pods
Distributes traffic across pod replicas
Rolling updates that change application versions without downtime
Quotas and limits to control cluster resource use
Network policies, RBAC, and secret management
DNS-based service discovery with load balancing
Persistent and ephemeral storage orchestration

Quick start

Install kubectl: Follow the Install and Configure kubectl section.

Access cluster: kubectl cluster-info

Create deployment: kubectl create deployment web --image=nginx

List resources: kubectl get pods,svc,deployments

Check application status: kubectl describe deployment web

Common workflows

Deploy Application: Create Deployment with image, replicas, and resources
Expose Service: Create Service to access pods internally or externally
Configure Access: Set up Ingress or LoadBalancer for external traffic
Monitor Health: Check pod status, logs, and events regularly
Update Application: Use rolling updates or blue-green deployments
Scale Load: Adjust replicas manually or enable HPA for automatic scaling
Debug Issues: Examine logs, describe resources, execute debugging containers

The sections above cover pod management, deployments, services, storage, RBAC, and cluster operations.

Markdown

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Markdown is a lightweight markup language for writing formatted content with a simple, readable syntax. It was created for writing on the web, and is now used in documentation, blogs, and note-taking apps.

The sections below cover Markdown syntax, formatting options, and practical examples.

Netcat

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Complete netcat reference covering TCP/UDP connections, file transfers, server testing, port scanning, banner grabbing, and network troubleshooting with practical examples

Netstat

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Complete netstat reference covering network connections, listening ports, routing tables, and network statistics with practical examples

Screen

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Getting started

GNU Screen is a terminal multiplexer that gives you:

Sessions: Full terminal environments that persist even if you disconnect
Windows: Multiple terminals (tabs) within a single session
Splits: Horizontal and vertical screen divisions for side-by-side work
Copy/Paste: Built-in text selection and clipboard management
Automation: Scripts to auto-setup complex terminal layouts

Start your first screen session:

screen -S development

Then detach with Ctrl+A d and reattach from anywhere:

screen -r development

Key concepts

Sessions: Independent workspaces that continue running even if you disconnect. Useful for long-running server processes and preserving work state.

Windows: Tabs within a session. Each window is a full terminal shell with independent directory and command history.

Splits: Horizontal regions within a window. Allows side-by-side terminals without creating new windows (though for complex panes, tmux may be better).

Copy Mode: Special mode for selecting and copying text from the scrollback buffer for pasting later.

Essential keybindings

All keybindings use the prefix key Ctrl+A (abbreviated as C-a):

Session management

C-a d - Detach from session (background)
C-a D D - Detach and logout
C-a q - Exit screen

Windows

C-a c - Create new window
C-a n / C-a p - Next/previous window
C-a [0-9] - Jump to window number
C-a w - List all windows
C-a k - Kill current window
C-a A - Rename window

Splits and regions

C-a S - Split horizontally (regions)
C-a | - Split vertically (newer versions)
C-a Tab - Switch to next region
C-a X - Remove current region
C-a Q - Remove all regions

Copy and paste

C-a [ - Enter copy/scroll mode
Space - Start selection (in copy mode)
Enter - Copy selection (in copy mode)
C-a ] - Paste copied text
C-a = - Show paste buffers

Common Screen setup

Install and create your configuration file ~/.screenrc:

# ~/.screenrc - Essential configuration
# Increase scrollback history
defscrollback 10000

# Enable 256-color terminal
term screen-256color

# Don't show startup message
startup_message off

# Enable visual bell for notifications
vbell on

# Automatically detach on connection loss
autodetach on

# Useful custom bindings
bind h select -1
bind l select +1
bind - split -h
bind _ split -v

Load the config:

screen -c ~/.screenrc

Building a development session

Create a complete development environment automatically:

#!/bin/bash
# dev-session.sh - Create development environment

SESSION="dev"
screen -S "$SESSION" -d -m

# Create editor window
screen -S "$SESSION" -X new-window -t "editor"
screen -S "$SESSION" -p "editor" -X send-keys "cd ~/myproject && vim" Enter

# Create server window
screen -S "$SESSION" -X new-window -t "server"
screen -S "$SESSION" -p "server" -X send-keys "cd ~/myproject && npm start" Enter

# Create test window
screen -S "$SESSION" -X new-window -t "test"
screen -S "$SESSION" -p "test" -X send-keys "cd ~/myproject && npm test" Enter

# Attach and start
screen -r "$SESSION"

Run it anytime: bash dev-session.sh

Tips for productivity

Use Named Sessions: screen -S projectname is easier to remember than numbered sessions
Name Your Windows: Use C-a A to name windows (editor, server, monitor)
Detach Don't Exit: Always use C-a d to detach, not exit, so session persists
Create Session Templates: Save setup scripts for recurring project types
Organize by Project: One session per project with windows for different tasks
Use Splits for Monitoring: Split regions work well for watching logs while you work
Enable Scrollback: Set defscrollback 10000 in ~/.screenrc for adequate history
Combine with SSH: Screen keeps long-running remote tasks alive over SSH

Quick reference: session lifecycle

# Create session
screen -S mywork

# Inside screen - work normally, then detach
Ctrl+A d

# Check sessions
screen -ls

# Reattach to session
screen -r mywork

# Kill session when done
screen -S mywork -X quit

Screen vs Tmux

Screen is better for:

Simplicity and a smaller learning curve
Systems where tmux isn't available
Simple split layouts (left/right only)
Older servers that predate tmux

Tmux is better for:

Complex pane management
Modern development workflows
Extensive plugin ecosystem
Latest terminal features

Resources

Official GNU Screen Manual: https://www.gnu.org/software/screen/
Linux Manual Page: https://linux.die.net/man/1/screen
Practical Screen Tutorial: https://www.rackaid.com/blog/linux-screen-tutorial-and-how-to/

Sed

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

This sed reference covers basic text substitution through advanced scripting techniques, with practical examples for text processing, file editing, and automation.

Tmux

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

Tmux is a terminal multiplexer for managing multiple terminal sessions, windows, and panes within a single screen. This cheatsheet covers the commands, keybindings, and configuration options for everyday tmux usage.

Quick start

Start your first tmux session with a single command:

tmux new -s development

Then detach with C-b d and reattach from anywhere with:

tmux attach -t development

Key concepts

Sessions: Independent workspaces that continue running even if you disconnect. Useful for keeping servers and processes running.

Windows: Tabs within a session. Each window is a full terminal with its own working directory and history.

Panes: Splits within a window. Allows multiple shells side-by-side without opening new windows.

Essential keybindings

All keybindings use the prefix key C-b (Ctrl+B) unless configured otherwise:

C-b c - Create new window
C-b n / C-b p - Next/previous window
C-b % / C-b " - Split vertical/horizontal
C-b h/j/k/l - Navigate panes (requires vim-style config)
C-b [ - Enter scroll/copy mode
C-b d - Detach from session
C-b ? - List all keybindings
C-b : - Enter command mode

Popular configuration

For vim-style navigation and mouse support, add to ~/.tmux.conf:

# Enable 256 color support
set -g default-terminal "screen-256color"
set -ga terminal-overrides ",xterm-256color:RGB"

# Enable mouse
set -g mouse on

# Use vim keys for navigation
setw -g mode-keys vi
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# Resize panes with vim keys
bind H resize-pane -L 5
bind J resize-pane -D 5
bind K resize-pane -U 5
bind L resize-pane -R 5

# Increase history limit
set -g history-limit 50000

# Reload config
bind r source-file ~/.tmux.conf

Then reload with C-b : and type source-file ~/.tmux.conf.

Tips for productivity

Use Named Sessions: tmux new -s work is easier to remember than session numbers
Create Window Groups: Organize windows logically within sessions (editor, server, testing)
Pair Programming: Multiple users can attach to the same session at once
Automation: Use tmux send-keys in scripts to automate setup and testing
Mouse Support: Enable set -g mouse on to scroll and select panes with the mouse

Resources

Official Tmux Manual: https://linux.die.net/man/1/tmux
GitHub Repository: https://github.com/tmux/tmux
Community Wiki: https://github.com/tmux/tmux/wiki

TOML

Mohammad Abu Mattar — Fri, 28 Feb 2025 00:00:00 GMT

TOML (Tom's Obvious, Minimal Language) is a human-friendly configuration file format. Designed to be minimal, readable, and unambiguous, it's used extensively in package manifests (like Cargo.toml and pyproject.toml) and application configuration files.

Browse the sections below to explore TOML syntax, data types, and practical configuration examples.

JavaScript

Mohammad Abu Mattar — Thu, 27 Feb 2025 00:00:00 GMT

JavaScript is a high-level programming language that powers the web. It supports object-oriented, functional, and event-driven programming styles.

The sections below cover JavaScript syntax and methods, including ES6+ features, async patterns, classes, and modules.

Python

Mohammad Abu Mattar — Thu, 27 Feb 2025 00:00:00 GMT

Python is an interpreted, high-level programming language known for its readability and simplicity. It supports multiple programming paradigms including procedural, object-oriented, and functional programming.

The sections below cover Python syntax, functions, classes, and common patterns.

RegEx

Mohammad Abu Mattar — Thu, 27 Feb 2025 00:00:00 GMT

Regular expressions (regex or regexp) are patterns used to match character combinations in strings. They handle pattern matching, validation, and text processing across nearly all programming languages.

Browse the sections below to explore regex syntax, patterns, and practical examples.

Vim

Mohammad Abu Mattar — Thu, 27 Feb 2025 00:00:00 GMT

Vim is a highly configurable text editor built to make creating and changing any kind of text very efficient. It is included as "vi" with most UNIX systems.

The sections below cover Vim commands, shortcuts, and examples.

YAML

Mohammad Abu Mattar — Thu, 27 Feb 2025 00:00:00 GMT

YAML (YAML Ain't Markup Language) is a human-friendly data serialization language widely used for configuration files, data exchange, and infrastructure-as-code. It emphasizes readability and uses indentation to structure data.

The sections below cover YAML syntax, data structures, and practical examples.

Bash

Mohammad Abu Mattar — Sun, 01 Jan 2023 00:00:00 GMT

Bash is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell.

The sections below cover Bash commands, syntax, and examples.