Mohammad Abu Mattar | Cheatsheets

Linux Networking

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

Linux Networking

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

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

Terraform Cheatsheet

A practical cheatsheet covering the Terraform CLI commands engineers reach for constantly — init, plan, apply, import, taint, and state operations — alongside essential HCL patterns for variables, locals, outputs, and dynamic blocks.

Browse the sections below to explore Terraform cheatsheet commands, syntax, and examples.

AWS CLI

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

AWS CLI

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.

Browse the sections below to explore command syntax, operational insights, and advanced configuration mechanics.

Docker Swarm

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

Docker Swarm Cheatsheet

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

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', };

Ansible

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

Ansible Quick Reference Cheatsheet

Ansible is a powerful automation tool for configuration management, application deployment, and orchestration. This cheatsheet provides quick reference guides for common Ansible tasks, modules, and best practices to help you get started and work efficiently with Ansible.

Chef

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

Chef Quick Reference Cheatsheet

Chef is a powerful Infrastructure as Code platform for automating infrastructure configuration, deployment, and management. This cheatsheet provides comprehensive reference guides for Chef concepts, commands, patterns, and best practices to help you efficiently manage infrastructure with Chef Infra, Chef Server, and related tools.

Docker Compose

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

Docker Compose Cheatsheet

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

Dockerfile Cheat Sheet

This cheat sheet covers essential Dockerfile instructions, best practices, and common pitfalls for building efficient and secure Docker images. Whether you're new to Docker or looking to optimize your builds, this guide provides practical examples and explanations to help you master Dockerfile authoring.

PostgreSQL

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

PostgreSQL Quick Reference Cheatsheet

Comprehensive 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

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

VS Code

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

Visual Studio Code Cheatsheet

A quick reference guide for Visual Studio Code, covering essential keyboard shortcuts, features, and best practices for efficient coding and navigation.

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

Chmod Cheatsheet - File Permissions, Recursive Changes & Best Practices

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

Cron Cheatsheet

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 - 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 powerful command-line tool for transferring data using URLs. It supports a wide range of protocols and is indispensable for web development, API testing, and automated scripting. Whether you're testing a REST API, downloading files, or debugging HTTP connections, curl provides the tools you need.

What Makes cURL Essential

Protocol Support: HTTP, HTTPS, FTP, FTPS, SCP, SFTP, TELNET, LDAP, LDAPS, and more
Flexibility: Works with virtually any web service or API
Scripting: Perfect for automation and creating repeatable workflows
Debugging: Verbose output helps diagnose connection and API issues
Lightweight: No GUI required, 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 if resource exists without downloading

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

Security First: Always use HTTPS for authenticated requests
Handle Errors: Check exit codes and HTTP status codes
Use Variables: Store tokens and credentials in environment variables, not in scripts
Validate Input: Check JSON syntax and validate responses before processing
Add Timeouts: Prevent hanging requests with --max-time and --connect-timeout
Log Carefully: Redact sensitive data from logs
Test Before Production: Always test API calls against staging before production use
Document Your Calls: Comment curl commands explaining 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

Dart is a statically-typed, strongly null-safe programming language designed for building fast, multi-platform applications. Created by Google, Dart combines the best features of many languages while providing excellent tooling and powerful features for web, server, and mobile development.

Key features include:

Strong Null Safety: The type system enforces null safety, preventing null reference errors 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: Powerful 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.

Browse the categories below to explore Dart syntax, advanced features, and best practices.

Docker

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

Docker

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.

Key Benefits

Consistency: Run the same environment everywhere (dev, test, production)
Isolation: Applications are isolated from each other and the host system
Portability: Easily deploy containerized applications to any system with Docker
Efficiency: Lightweight compared to virtual machines, fast startup times
Scalability: Easy to scale applications horizontally by running multiple 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

Browse the sections above to learn 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

Git is a distributed version control system that enables developers to track code changes, collaborate with teams, and manage project history efficiently. It's the foundation of modern software development workflows.

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

Browse the sections above to master Git workflows, from basic commands to advanced techniques for managing complex projects.

Go

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

Go

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

Browse the sections below to explore 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 create powerful 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 extensively (^ 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; ensure piped input is 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

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

Key Benefits

Simplified Deployment: Deploy entire application stacks with a single command
Reusability: Share and reuse charts across projects and teams
Configuration Management: Override values without editing templates
Version Control: Track and rollback to previous releases easily
Dependency Management: Include and manage chart dependencies automatically
Scalability: Quickly deploy multiple 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

Browse the sections above to master Helm from basics to advanced production scenarios.

JSON

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

JSON

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

Kubernetes is the de facto standard for container orchestration. It automates deployment, scaling, and management of containerized applications across clusters of machines, providing declarative configuration and powerful self-healing capabilities.

Key Features

Automated Deployment: Deploy containers to nodes automatically
Self-Healing: Restarts failed containers, replaces unhealthy pods
Load Balancing: Distribute traffic across pod replicas
Rolling Updates: Gradually update application versions without downtime
Resource Management: Optimize cluster resource utilization with quotas and limits
Security: Network policies, RBAC, and secret management
Service Discovery: Automatic DNS and load balancing for services
Storage Orchestration: Manage persistent and ephemeral storage

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

Explore the sections above to master Kubernetes from basic pod management to advanced security and operations.

Markdown

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

Markdown

Markdown is a lightweight markup language designed for creating formatted content with a simple, readable syntax. Originally created for web writing, it's now used everywhere from documentation to blogs to note-taking apps.

Browse the sections below to explore Markdown syntax, formatting options, and practical examples.

Netcat

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

This comprehensive netcat cheatsheet provides complete coverage of TCP/UDP connections, file transfers, port scanning, banner grabbing, and advanced network operations.

Netstat

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

This comprehensive netstat cheatsheet is now ready for your portfolio website. All 6 major categories have been created with detailed examples, explanations, and practical troubleshooting techniques.

Screen

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

GNU Screen Cheatsheet

Getting Started

GNU Screen is a powerful 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. Great 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 is invaluable over SSH for long-running remote tasks

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 - 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

Sed (Stream Editor) Cheatsheet - Text Processing, Substitution, and Automation

This comprehensive sed reference covers everything from basic text substitution to advanced scripting techniques. Learn how to use sed for powerful text processing, file editing, and automation with practical examples and best practices.

Tmux

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

Tmux Cheatsheet

Tmux is a powerful terminal multiplexer that allows you to manage multiple terminal sessions, windows, and panes within a single screen. This cheatsheet covers essential commands, keybindings, and configuration options for effective 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 for collaboration
Automation: Use tmux send-keys in scripts to automate setup and testing
Mouse Support: Enable set -g mouse on for modern terminal comfort with familiar scrolling

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

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

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

Browse the sections below to explore JavaScript syntax, methods, and examples covering ES6+ features, async patterns, classes, modules, and more.

Python

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

Python

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.

Browse the sections below to explore Python syntax, functions, classes, and common patterns.

RegEx

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

RegEx

Regular expressions (regex or regexp) are powerful patterns used to match character combinations in strings. They enable sophisticated 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

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.

Browse the sections below to explore Vim commands, shortcuts, and examples.

YAML

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

YAML

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 intuitive indentation to structure data.

Browse the sections below to explore YAML syntax, data structures, and practical examples.

Bash

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

Bash

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.

Browse the sections below to explore Bash commands, syntax, and examples.