Tools on QuickRef - Personal Developer Reference

CocoaPods

Wed, 08 Apr 2026 00:00:00 +0000

Overview

CocoaPods is a dependency manager for Swift and Objective-C Cocoa projects. It simplifies the process of integrating third-party libraries (known as “pods”) into your Xcode projects, handling versioning and transitive dependencies.

Installation

CocoaPods is built with Ruby and can be installed using the default Ruby available on macOS.

# Install CocoaPods
sudo gem install cocoapods

# Install a pre-release version
sudo gem install cocoapods --pre

Basic Workflow

Podfile

A Podfile is a specification that describes the dependencies of a project.

KiCad

Wed, 03 Sep 2025 00:00:00 +0000

Overview

KiCad is a cross-platform and open-source Electronic Design Automation (EDA) suite. It includes a schematic editor, a PCB layout tool, a 3D viewer, and a Gerber file viewer. It’s a powerful tool for designing and manufacturing printed circuit boards (PCBs).

Installation

# Ubuntu/Debian
sudo add-apt-repository --yes ppa:kicad/kicad-6.0-releases
sudo apt update
sudo apt install --install-recommends kicad

# macOS
brew install --cask kicad

# Windows
# Download from https://www.kicad.org/download/windows/

General Hotkeys

Hotkey	Action
`Ctrl+N`	New Project
`Ctrl+O`	Open Project
`Ctrl+S`	Save File
`Ctrl+Z`	Undo
`Ctrl+Y`	Redo
`Ctrl+F`	Find
`F1`	Help
`Alt+F4`	Exit

Schematic Editor Hotkeys

General

Hotkey	Action
`?`	List all hotkeys
`Space`	Start placing a component
`A`	Add a symbol
`W`	Wire
`B`	Bus
`J`	Junction
`L`	Label
`T`	Text
`K`	No-Connection Flag
`V`	Value
`F`	Field
`U`	Update PCB from Schematic

Component Manipulation

Hotkey	Action
`M`	Move
`R`	Rotate
`G`	Drag
`C`	Copy
`Del`	Delete
`E`	Edit
`Q`	Edit Value

PCB Editor Hotkeys

General

Hotkey	Action
`?`	List all hotkeys
`PageUp`	Switch to Top Layer
`PageDown`	Switch to Bottom Layer
`+`	Next Layer
`-`	Previous Layer
`F5`	Switch to Top Layer
`F6`	Switch to Bottom Layer
`F7`	Switch to Inner Layer 1
`F8`	Switch to Inner Layer 2
`Tab`	Highlight Net
`~`	Show/Hide Ratsnest

Drawing

Hotkey	Action
`X`	Route Tracks
`V`	Add Via
`D`	Drag Track
`G`	Drag Item
`Ctrl+M`	Move Exactly
`F`	Flip Item to Opposite Side
`Z`	Add Filled Zone
`Ctrl+B`	Refill All Zones

3D Viewer

Hotkey	Action
`Z`	Zoom to Fit
`R`	Reload 3D View
`O`	Orthographic Projection
`P`	Perspective Projection

Tips and Tricks

Use Projects: Always start with a project file (.pro) to keep your schematic and PCB files linked.
Libraries: KiCad comes with a large library of symbols and footprints. You can also add your own or download them from the internet.
Design Rules: Set up your design rules in the PCB editor to ensure your board can be manufactured.
3D Viewer: Use the 3D viewer to check for mechanical conflicts and to get a realistic view of your board.
Custom Hotkeys: You can customize the hotkeys in the preferences to match your workflow.

ADB (Android Debug Bridge)

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Android Debug Bridge (ADB) is a versatile command-line tool that lets you communicate with a device. The adb command facilitates a variety of device actions, such as installing and debugging apps, and it provides access to a Unix shell that you can use to run a variety of commands on a device.

Installation

# Ubuntu/Debian
sudo apt install adb

# macOS
brew install --cask android-platform-tools

# CentOS/RHEL
sudo yum install android-tools

# Windows
# Download from https://developer.android.com/studio/releases/platform-tools

Basic Commands

Device Management

# List connected devices
adb devices

# Start the adb server
adb start-server

# Kill the adb server
adb kill-server

# Get device state
adb get-state

# Wait for device to be connected
adb wait-for-device

File Management

# Push a file to the device
adb push local.txt /sdcard/remote.txt

# Pull a file from the device
adb pull /sdcard/remote.txt local.txt

# List files on the device
adb shell ls /sdcard/

App Management

Installing and Uninstalling Apps

# Install an APK
adb install app.apk

# Reinstall an existing app, keeping its data
adb install -r app.apk

# Uninstall an app
adb uninstall com.example.app

# Uninstall an app, keeping its data and cache
adb uninstall -k com.example.app

App Information

# List all installed packages
adb shell pm list packages

# List all installed packages with their associated file
adb shell pm list packages -f

# List third-party packages
adb shell pm list packages -3

# Get the path to an APK
adb shell pm path com.example.app

Debugging

Logcat

# View logs from the device
adb logcat

# Filter logs by tag
adb logcat -s "MyApp"

# Clear the logcat buffer
adb logcat -c

Shell Access

# Start a remote shell on the device
adb shell

# Execute a single command on the device
adb shell "ls -l /sdcard/"

Advanced Commands

Port Forwarding

# Forward a device port to a local port
adb forward tcp:8080 tcp:8080

# List all forwarded ports
adb forward --list

Screenshots and Screen Recording

# Take a screenshot
adb shell screencap /sdcard/screenshot.png

# Record the device screen
adb shell screenrecord /sdcard/demo.mp4

Quick Reference

Common Commands

adb devices # List connected devices
adb shell # Enter a remote shell
adb push <local> <remote> # Push a file to the device
adb pull <remote> <local> # Pull a file from the device
adb install <apk> # Install an app
adb uninstall <package> # Uninstall an app
adb logcat # View device logs

Curl

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Curl is a command-line tool for transferring data from or to servers using various protocols including HTTP, HTTPS, FTP, and more. It’s essential for API testing, web scraping, downloading files, and debugging network requests.

Installation

# Ubuntu/Debian
sudo apt install curl

# macOS (usually pre-installed)
brew install curl

# CentOS/RHEL
sudo yum install curl

# Windows
# Download from https://curl.se/windows/

Basic Usage

Simple GET Request

# Basic GET request
curl https://api.example.com

# GET with verbose output
curl -v https://api.example.com

# GET with headers only
curl -I https://api.example.com

Download Files

# Download file
curl -O https://example.com/file.zip

# Download with custom filename
curl -o myfile.zip https://example.com/file.zip

# Download multiple files
curl -O https://example.com/file1.zip -O https://example.com/file2.zip

HTTP Methods

GET Requests

# Simple GET
curl https://api.example.com/users

# GET with query parameters
curl "https://api.example.com/users?page=1&limit=10"

# GET with URL encoding
curl -G -d "q=search term" -d "page=1" https://api.example.com/search

POST Requests

# POST with data
curl -X POST -d "name=John&email=john@example.com" https://api.example.com/users

# POST with JSON data
curl -X POST \
 -H "Content-Type: application/json" \
 -d '{"name":"John","email":"john@example.com"}' \
 https://api.example.com/users

# POST with file data
curl -X POST \
 -H "Content-Type: application/json" \
 -d @data.json \
 https://api.example.com/users

PUT Requests

# PUT request
curl -X PUT \
 -H "Content-Type: application/json" \
 -d '{"name":"John Updated"}' \
 https://api.example.com/users/123

DELETE Requests

# DELETE request
curl -X DELETE https://api.example.com/users/123

# DELETE with authentication
curl -X DELETE \
 -H "Authorization: Bearer token123" \
 https://api.example.com/users/123

PATCH Requests

# PATCH request
curl -X PATCH \
 -H "Content-Type: application/json" \
 -d '{"name":"Partially Updated"}' \
 https://api.example.com/users/123

Headers and Authentication

Custom Headers

# Add custom header
curl -H "Authorization: Bearer token123" https://api.example.com

# Multiple headers
curl -H "Authorization: Bearer token123" \
 -H "Content-Type: application/json" \
 -H "User-Agent: MyApp/1.0" \
 https://api.example.com

# Remove default headers
curl -H "User-Agent:" https://api.example.com

Authentication

Basic Authentication

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

# Basic auth with prompt for password
curl -u username https://api.example.com

# Basic auth with encoded credentials
curl -H "Authorization: Basic dXNlcjpwYXNz" https://api.example.com

Bearer Token

# Bearer token
curl -H "Authorization: Bearer your-token-here" https://api.example.com

# OAuth token
curl -H "Authorization: OAuth oauth-token" https://api.example.com

API Key

# API key in header
curl -H "X-API-Key: your-api-key" https://api.example.com

# API key in query parameter
curl "https://api.example.com/data?api_key=your-api-key"

Data Formats

JSON Data

# JSON POST
curl -X POST \
 -H "Content-Type: application/json" \
 -d '{"key":"value","number":42}' \
 https://api.example.com

# JSON from file
curl -X POST \
 -H "Content-Type: application/json" \
 -d @data.json \
 https://api.example.com

Form Data

# URL-encoded form data
curl -X POST \
 -H "Content-Type: application/x-www-form-urlencoded" \
 -d "name=John&email=john@example.com" \
 https://api.example.com

# Form data (automatic content-type)
curl -X POST \
 -d "name=John" \
 -d "email=john@example.com" \
 https://api.example.com

Multipart Form Data

# File upload
curl -X POST \
 -F "file=@document.pdf" \
 https://api.example.com/upload

# Mixed form data
curl -X POST \
 -F "name=John" \
 -F "email=john@example.com" \
 -F "avatar=@profile.jpg" \
 https://api.example.com/users

XML Data

# XML POST
curl -X POST \
 -H "Content-Type: application/xml" \
 -d '<user><name>John</name><email>john@example.com</email></user>' \
 https://api.example.com

Output and Formatting

Output Control

# Save response to file
curl -o response.json https://api.example.com

# Append to file
curl -o response.json https://api.example.com

# Silent mode (no progress bar)
curl -s https://api.example.com

# Show only HTTP status code
curl -s -o /dev/null -w "%{http_code}" https://api.example.com

Response Information

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

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

# Verbose output
curl -v https://api.example.com

# Show response time
curl -w "%{time_total}\n" -o /dev/null -s https://api.example.com

Pretty Print JSON

# Format JSON output (with jq)
curl -s https://api.example.com | jq '.'

# Format JSON with Python
curl -s https://api.example.com | python -m json.tool

# Save formatted JSON
curl -s https://api.example.com | jq '.' > formatted.json

Advanced Features

Follow Redirects

# Follow redirects
curl -L https://example.com

# Follow redirects with max count
curl -L --max-redirs 5 https://example.com

# Show redirect chain
curl -L -v https://example.com

Cookies

# Save cookies
curl -c cookies.txt https://example.com

# Load cookies
curl -b cookies.txt https://example.com

# Use specific cookie
curl -H "Cookie: sessionid=abc123" https://example.com

Timeouts and Retries

# Connection timeout
curl --connect-timeout 10 https://api.example.com

# Maximum time for request
curl --max-time 30 https://api.example.com

# Retry on failure
curl --retry 3 https://api.example.com

# Retry with delay
curl --retry 3 --retry-delay 2 https://api.example.com

Proxy Support

# Use HTTP proxy
curl --proxy http://proxy.example.com:8080 https://api.example.com

# Use SOCKS proxy
curl --socks5 proxy.example.com:1080 https://api.example.com

# Proxy authentication
curl --proxy-user username:password \
 --proxy http://proxy.example.com:8080 \
 https://api.example.com

SSL/TLS Options

SSL Verification

# Skip SSL verification (insecure)
curl -k https://self-signed.example.com

# Use specific CA certificate
curl --cacert ca-cert.pem https://api.example.com

# Use client certificate
curl --cert client-cert.pem --key client-key.pem https://api.example.com

SSL Information

# Show SSL certificate info
curl -v https://api.example.com 2>&1 | grep -A 10 "Server certificate"

# Check SSL certificate expiration
curl -v https://api.example.com 2>&1 | grep "expire date"

Testing APIs

REST API Testing

# Test API endpoint
curl -X GET \
 -H "Accept: application/json" \
 https://api.example.com/v1/users

# Test with authentication
curl -X GET \
 -H "Authorization: Bearer token123" \
 -H "Accept: application/json" \
 https://api.example.com/v1/users/me

# Test error handling
curl -X GET \
 -H "Accept: application/json" \
 https://api.example.com/v1/nonexistent

GraphQL API Testing

# GraphQL query
curl -X POST \
 -H "Content-Type: application/json" \
 -d '{"query":"query { users { id name email } }"}' \
 https://api.example.com/graphql

# GraphQL mutation
curl -X POST \
 -H "Content-Type: application/json" \
 -d '{"query":"mutation { createUser(name: \"John\", email: \"john@example.com\") { id name } }"}' \
 https://api.example.com/graphql

Health Checks

# Simple health check
curl -f https://api.example.com/health

# Health check with timeout
curl -f --max-time 5 https://api.example.com/health

# Health check script
#!/bin/bash
if curl -f -s https://api.example.com/health > /dev/null; then
 echo "Service is healthy"
else
 echo "Service is down"
fi

Practical Examples

Download and Extract

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

# Download and pipe to command
curl -s https://api.example.com/data | jq '.results[]'

API Testing Script

#!/bin/bash
API_BASE="https://api.example.com"
TOKEN="your-token-here"

# Test authentication
echo "Testing authentication..."
curl -s -H "Authorization: Bearer $TOKEN" "$API_BASE/auth/test"

# Test GET endpoint
echo "Testing GET endpoint..."
curl -s -H "Authorization: Bearer $TOKEN" "$API_BASE/users" | jq '.'

# Test POST endpoint
echo "Testing POST endpoint..."
curl -s -X POST \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"name":"Test User","email":"test@example.com"}' \
 "$API_BASE/users" | jq '.'

Web Scraping

# Download webpage
curl -s https://example.com | grep -o '<title>.*</title>'

# Download images from webpage
curl -s https://example.com | grep -o 'src="[^"]*\.jpg"' | cut -d'"' -f2 | xargs -I {} curl -O {}

# Check HTTP status codes
curl -s -o /dev/null -w "%{http_code} %{url_effective}\n" https://example.com

Error Handling

Common HTTP Status Codes

# Check for specific status codes
curl -s -o /dev/null -w "%{http_code}" https://api.example.com
# 200 - OK
# 401 - Unauthorized
# 404 - Not Found
# 500 - Server Error

Error Handling in Scripts

#!/bin/bash
response=$(curl -s -w "%{http_code}" https://api.example.com)
status_code="${response: -3}"
body="${response%???}"

if [ "$status_code" -eq 200 ]; then
 echo "Success: $body"
else
 echo "Error: HTTP $status_code"
 echo "Response: $body"
fi

Configuration

Config File (~/.curlrc)

# Default options
user-agent = "MyApp/1.0"
connect-timeout = 10
max-time = 30
retry = 3
silent
show-error

Environment Variables

# Set proxy
export HTTP_PROXY=http://proxy.example.com:8080
export HTTPS_PROXY=http://proxy.example.com:8080

# Set CA certificate path
export CURL_CA_BUNDLE=/path/to/ca-bundle.crt

Quick Reference

Common Options

-X, --request # HTTP method
-H, --header # Add header
-d, --data # POST data
-F, --form # Form data
-o, --output # Output file
-O, --remote-name # Use remote filename
-u, --user # Authentication
-v, --verbose # Verbose output
-s, --silent # Silent mode
-I, --head # Headers only
-L, --location # Follow redirects
-k, --insecure # Skip SSL verification

Format Strings

%{http_code} # HTTP status code
%{time_total} # Total time
%{time_connect} # Connection time
%{size_download} # Download size
%{speed_download} # Download speed
%{url_effective} # Final URL

Tips and Tricks

Performance Testing

# Measure response time
curl -w "@curl-format.txt" -o /dev/null -s https://api.example.com

# curl-format.txt content:
# time_namelookup: %{time_namelookup}\n
# time_connect: %{time_connect}\n
# time_appconnect: %{time_appconnect}\n
# time_pretransfer: %{time_pretransfer}\n
# time_redirect: %{time_redirect}\n
# time_starttransfer: %{time_starttransfer}\n
# ----------\n
# time_total: %{time_total}\n

Debugging

# Debug with verbose output
curl -v https://api.example.com

# Debug with trace
curl --trace-ascii debug.txt https://api.example.com

# Debug SSL
curl -v --trace-ascii ssl-debug.txt https://api.example.com

Docker

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Docker is a platform that enables developers to package applications and their dependencies into lightweight, portable containers. It provides consistent environments across development, testing, and production, making application deployment more reliable and scalable.

Installation

# Ubuntu/Debian
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# macOS
brew install docker # OpenSource & recommended
brew install --cask docker # NOT OPEN SOURCE
# or download Docker Desktop from https://docker.com

# CentOS/RHEL
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install docker-ce docker-ce-cli containerd.io

# Start Docker service
sudo systemctl start docker
sudo systemctl enable docker

My way of installation on mac

I prefer to use the open source version of the docker, hence these are the steps i had to take to download and install the docker on my device.

Git

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Git is a distributed version control system that tracks changes in files and coordinates work among multiple developers. It’s essential for software development, enabling collaboration, version tracking, and code management.

Installation

# Ubuntu/Debian
sudo apt install git

# macOS
brew install git
# or use Xcode Command Line Tools
xcode-select --install

# CentOS/RHEL
sudo yum install git

# Windows
# Download from https://git-scm.com/download/win

Initial Setup

Configuration

# Set global username and email
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

# Set default editor
git config --global core.editor "vim"

# Set default branch name
git config --global init.defaultBranch main

# List all configurations
git config --list

SSH Key Setup

# Generate SSH key
ssh-keygen -t ed25519 -C "your.email@example.com"

# Start SSH agent
eval "$(ssh-agent -s)"

# Add key to agent
ssh-add ~/.ssh/id_ed25519

# Copy public key to clipboard
cat ~/.ssh/id_ed25519.pub
# Add to GitHub/GitLab/etc.

Repository Basics

Creating Repositories

# Initialize new repository
git init

# Initialize with specific branch
git init -b main

# Clone existing repository
git clone https://github.com/user/repo.git

# Clone with specific name
git clone https://github.com/user/repo.git my-project

# Clone specific branch
git clone -b branch-name https://github.com/user/repo.git

Repository Status

# Check status
git status

# Short status
git status -s

# Show branch information
git branch -v

# Show remote information
git remote -v

Basic Workflow

Staging Changes

# Add specific file
git add filename.txt

# Add all files
git add .

# Add all files in directory
git add src/

# Add by pattern
git add "*.js"

# Interactive staging
git add -i

# Add patches interactively
git add -p

Committing Changes

# Commit with message
git commit -m "Add new feature"

# Commit with detailed message
git commit -m "Add user authentication" -m "Detailed description here"

# Commit all tracked changes
git commit -a -m "Update existing files"

# Amend last commit
git commit --amend -m "Updated commit message"

# Commit with specific author
git commit --author="Name <email@example.com>" -m "Message"

Viewing History

# Show commit history
git log

# Show concise history
git log --oneline

# Show graph
git log --graph --oneline --all

# Show specific number of commits
git log -n 5

# Show commits by author
git log --author="John Doe"

# Show commits since date
git log --since="2 weeks ago"

# Show file changes
git log --stat

Branching

Creating Branches

# Create new branch
git branch feature-branch

# Create and switch to branch
git checkout -b feature-branch

# Create branch from specific commit
git checkout -b hotfix abc1234

# Create branch from remote
git checkout -b local-branch origin/remote-branch

Switching Branches

# Switch to branch
git checkout branch-name

# Switch to previous branch
git checkout -

# Switch using newer syntax
git switch branch-name

# Create and switch (newer syntax)
git switch -c new-branch

Managing Branches

# List branches
git branch

# List all branches (including remote)
git branch -a

# List remote branches
git branch -r

# Delete branch
git branch -d branch-name

# Force delete branch
git branch -D branch-name

# Rename branch
git branch -m old-name new-name

# Rename current branch
git branch -m new-name

Remote Repositories

Adding Remotes

# Add remote
git remote add origin https://github.com/user/repo.git

# Add multiple remotes
git remote add upstream https://github.com/original/repo.git

# Change remote URL
git remote set-url origin https://github.com/user/new-repo.git

# Remove remote
git remote remove origin

Fetching and Pulling

# Fetch from remote
git fetch origin

# Fetch all remotes
git fetch --all

# Pull (fetch + merge)
git pull origin main

# Pull with rebase
git pull --rebase origin main

# Pull specific branch
git pull origin feature-branch

Pushing Changes

# Push to remote
git push origin main

# Push new branch
git push -u origin feature-branch

# Push all branches
git push --all origin

# Push tags
git push --tags origin

# Force push (dangerous)
git push --force origin main

# Force push with lease (safer)
git push --force-with-lease origin main

Merging and Rebasing

Merging

# Merge branch into current
git merge feature-branch

# Merge with no fast-forward
git merge --no-ff feature-branch

# Merge with squash
git merge --squash feature-branch

# Abort merge
git merge --abort

# Continue merge after resolving conflicts
git merge --continue

Rebasing

# Rebase current branch onto main
git rebase main

# Interactive rebase
git rebase -i HEAD~3

# Rebase onto specific commit
git rebase --onto main feature-branch

# Abort rebase
git rebase --abort

# Continue rebase after resolving conflicts
git rebase --continue

# Skip current commit during rebase
git rebase --skip

Resolving Conflicts

Conflict Resolution

# Show conflicts
git status

# View conflicted file
cat conflicted-file.txt

# Resolve conflicts manually, then:
git add conflicted-file.txt
git commit

# Use merge tool
git mergetool

# Abort merge/rebase
git merge --abort
git rebase --abort

Conflict Prevention

# Check for conflicts before merging
git merge --no-commit --no-ff feature-branch

# Fetch and check differences
git fetch origin
git diff HEAD origin/main

Undoing Changes

Working Directory

# Discard changes in file
git checkout -- filename.txt

# Discard all changes
git checkout .

# Restore file (newer syntax)
git restore filename.txt

# Restore all files
git restore .

Staging Area

# Unstage file
git reset filename.txt

# Unstage all files
git reset

# Unstage with newer syntax
git restore --staged filename.txt

Commits

# Undo last commit (keep changes)
git reset --soft HEAD~1

# Undo last commit (discard changes)
git reset --hard HEAD~1

# Undo specific commit
git revert abc1234

# Reset to specific commit
git reset --hard abc1234

# Create new commit that undoes changes
git revert HEAD

Stashing

Basic Stashing

# Stash changes
git stash

# Stash with message
git stash save "Work in progress"

# Stash including untracked files
git stash -u

# Stash specific files
git stash push -m "message" filename.txt

Managing Stashes

# List stashes
git stash list

# Show stash contents
git stash show

# Apply latest stash
git stash apply

# Apply specific stash
git stash apply stash@{1}

# Pop stash (apply and remove)
git stash pop

# Drop stash
git stash drop stash@{1}

# Clear all stashes
git stash clear

Advanced Features

Searching

# Search in files
git grep "search term"

# Search in specific files
git grep "search term" "*.js"

# Search in commit messages
git log --grep="fix bug"

# Search in commit content
git log -S "function name"

# Show commits that added/removed line
git log -p -S "search term"

Blame and History

# Show file annotations
git blame filename.txt

# Show file history
git log --follow filename.txt

# Show who changed lines
git blame -L 10,20 filename.txt

# Show changes in specific commit
git show abc1234

# Show changes between commits
git diff abc1234..def5678

Submodules

# Add submodule
git submodule add https://github.com/user/repo.git libs/repo

# Initialize submodules
git submodule init

# Update submodules
git submodule update

# Clone with submodules
git clone --recursive https://github.com/user/repo.git

# Update submodules to latest
git submodule update --remote

Configuration

Global Config

# Common settings
git config --global core.autocrlf input
git config --global core.safecrlf true
git config --global push.default simple
git config --global pull.rebase true
git config --global rerere.enabled true

Aliases

# Common aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'
git config --global alias.lg 'log --graph --pretty=format:"%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset" --abbrev-commit'

Ignore Files

# Create .gitignore file
echo "node_modules/" >> .gitignore
echo "*.log" >> .gitignore
echo ".env" >> .gitignore

# Global gitignore
git config --global core.excludesfile ~/.gitignore_global

Git Workflows

Feature Branch Workflow

# Create feature branch
git checkout -b feature/new-feature

# Work on feature
git add .
git commit -m "Add new feature"

# Push feature branch
git push -u origin feature/new-feature

# Create pull request (on GitHub/GitLab)
# After approval, merge and cleanup
git checkout main
git pull origin main
git branch -d feature/new-feature

Gitflow Workflow

# Initialize gitflow
git flow init

# Start feature
git flow feature start new-feature

# Finish feature
git flow feature finish new-feature

# Start release
git flow release start 1.0.0

# Finish release
git flow release finish 1.0.0

# Start hotfix
git flow hotfix start critical-fix

# Finish hotfix
git flow hotfix finish critical-fix

GitHub Flow

# Create branch from main
git checkout main
git pull origin main
git checkout -b feature-branch

# Make changes and commit
git add .
git commit -m "Implement feature"

# Push and create PR
git push -u origin feature-branch

# After PR merge, cleanup
git checkout main
git pull origin main
git branch -d feature-branch

Troubleshooting

Common Issues

# Fix "detached HEAD" state
git checkout main

# Recover deleted branch
git reflog
git checkout -b recovered-branch abc1234

# Fix merge conflicts
git status
# Edit conflicted files
git add .
git commit

# Undo accidental commit
git reset --soft HEAD~1

# Clean untracked files
git clean -fd

# Fix line endings
git config core.autocrlf true
git rm --cached -r .
git reset --hard

Recovery

# Show reflog
git reflog

# Recover lost commits
git cherry-pick abc1234

# Recover deleted branch
git branch recovered-branch abc1234

# Find lost commits
git fsck --lost-found

# Garbage collection
git gc --prune=now

Best Practices

Commit Messages

# Good commit message format
git commit -m "Add user authentication feature

- Implement login/logout functionality
- Add password hashing
- Create user session management
- Add input validation

Closes #123"

Branch Naming

# Good branch names
feature/user-authentication
bugfix/login-error
hotfix/security-patch
release/v1.2.0

Repository Hygiene

# Regular maintenance
git fetch --prune
git branch -d merged-branch
git tag -d old-tag
git gc --aggressive

Quick Reference

Essential Commands

# Repository setup
git init
git clone <url>
git remote add origin <url>

# Basic workflow
git add .
git commit -m "message"
git push origin main
git pull origin main

# Branching
git branch feature
git checkout feature
git merge feature
git branch -d feature

# Status and history
git status
git log --oneline
git diff

Useful Aliases

git config --global alias.s status
git config --global alias.a 'add .'
git config --global alias.c 'commit -m'
git config --global alias.p 'push origin HEAD'
git config --global alias.l 'log --oneline'
git config --global alias.co checkout
git config --global alias.br branch

Grep

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Grep is a command-line utility for searching plain-text data sets for lines that match a regular expression. It’s one of the most powerful and frequently used tools in Unix/Linux systems.

Basic Usage

grep "pattern" filename

Example:

# Search for the word "error" in log file
grep "error" /var/log/system.log

Common Options

Case & Matching

-i - Ignore case
-v - Invert match (exclude)
-w - Match whole words
-x - Match whole lines
-F - Fixed strings (no regex)
-E - Extended regex

Output Control

-n - Show line numbers
-c - Count matches
-l - List matching files
-L - List non-matching files
-o - Show only matches
-q - Quiet mode

Context Options

# Show 3 lines after match
grep -A 3 "pattern" file

# Show 3 lines before match
grep -B 3 "pattern" file

# Show 3 lines around match
grep -C 3 "pattern" file

Regular Expressions

Basic Patterns

^ - Start of line
$ - End of line
. - Any character
* - Zero or more
+ - One or more (with -E)
? - Zero or one (with -E)

Character Classes

[abc] - Any of a, b, c
[^abc] - Not a, b, c
[a-z] - Any lowercase
[0-9] - Any digit
\d - Digit (with -P)
\w - Word character (with -P)

Practical Examples

Search for IP addresses:

grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" file.txt

Search for email addresses:

grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" file.txt

Search in multiple files:

grep -r "TODO" /path/to/project

Search with file patterns:

grep -r --include="*.js" "console.log" .

Count occurrences:

grep -c "error" /var/log/system.log

Show only matching part:

grep -o "[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}" access.log

File Operations

Recursive Search

grep -r "pattern" /path
grep -R "pattern" /path

Include/Exclude Files

grep -r --include="*.txt" "pattern" .
grep -r --exclude="*.log" "pattern" .

Useful Combinations

Search for functions in code:

grep -n "function.*(" *.js

Find files containing pattern:

grep -l "pattern" *.txt

Search case-insensitive with line numbers:

grep -in "error" /var/log/system.log

Exclude binary files:

grep -I "pattern" *

Search for multiple patterns:

grep -E "error|warning|critical" /var/log/system.log

Exit Codes

0 - Match found
1 - No match found
2 - Error occurred

Tips and Tricks

Use grep --help for complete option list
Combine with other tools: ps aux | grep process_name
Use aliases for common patterns: alias finderr='grep -r "error" .'
For complex patterns, consider using egrep (equivalent to grep -E)

jq

Sun, 01 Jan 2023 00:00:00 +0000

Overview

jq is a lightweight and flexible command-line JSON processor. It’s like sed for JSON data, allowing you to slice, filter, map, and transform structured data with ease. Essential for API testing, data processing, and JSON manipulation.

Installation

# Ubuntu/Debian
sudo apt install jq

# macOS
brew install jq

# CentOS/RHEL
sudo yum install jq

# Windows
# Download from https://stedolan.github.io/jq/download/

Basic Usage

Simple Filtering

# Pretty print JSON
echo '{"name":"John","age":30}' | jq '.'

# Extract field
echo '{"name":"John","age":30}' | jq '.name'

# Extract nested field
echo '{"user":{"name":"John","age":30}}' | jq '.user.name'

# Extract array element
echo '["apple","banana","cherry"]' | jq '.[0]'

Array Operations

# Get array length
echo '[1,2,3,4,5]' | jq 'length'

# Get all elements
echo '[1,2,3,4,5]' | jq '.[]'

# Get specific elements
echo '[1,2,3,4,5]' | jq '.[1:3]' # Elements 1-2
echo '[1,2,3,4,5]' | jq '.[-2:]' # Last 2 elements

Data Types

Working with Objects

# Get all keys
echo '{"name":"John","age":30,"city":"NYC"}' | jq 'keys'

# Get all values
echo '{"name":"John","age":30,"city":"NYC"}' | jq 'values'

# Check if key exists
echo '{"name":"John","age":30}' | jq 'has("name")'

# Get type of value
echo '{"name":"John","age":30}' | jq '.age | type'

Working with Arrays

# Add element
echo '[1,2,3]' | jq '. + [4]'

# Remove element
echo '[1,2,3,4]' | jq 'del(.[1])'

# Reverse array
echo '[1,2,3,4]' | jq 'reverse'

# Sort array
echo '[3,1,4,2]' | jq 'sort'

# Unique elements
echo '[1,2,2,3,3,3]' | jq 'unique'

Filtering and Selection

Basic Filters

# Select objects with specific field
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq '.[] | select(.age > 25)'

# Select objects with specific value
echo '[{"name":"John","active":true},{"name":"Jane","active":false}]' | jq '.[] | select(.active)'

# Select objects with key
echo '[{"name":"John"},{"age":30}]' | jq '.[] | select(has("name"))'

Complex Filters

# Multiple conditions
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq '.[] | select(.age > 25 and .name == "John")'

# Regular expression matching
echo '[{"name":"John"},{"name":"Jane"}]' | jq '.[] | select(.name | test("J.*"))'

# Empty or null values
echo '[{"name":"John"},{"name":null},{}]' | jq '.[] | select(.name != null)'

Transformations

Map Operations

# Transform array elements
echo '[1,2,3,4]' | jq 'map(. * 2)'

# Transform object fields
echo '[{"name":"john"},{"name":"jane"}]' | jq 'map(.name | ascii_upcase)'

# Add field to objects
echo '[{"name":"John"},{"name":"Jane"}]' | jq 'map(. + {"active": true})'

Object Construction

# Create new object
echo '{"first":"John","last":"Doe"}' | jq '{name: (.first + " " + .last)}'

# Multiple fields
echo '{"name":"John","age":30}' | jq '{user: .name, years: .age}'

# Conditional fields
echo '{"name":"John","age":30}' | jq '{name, age: (if .age > 25 then "adult" else "young" end)}'

String Operations

# String interpolation
echo '{"name":"John","age":30}' | jq '"Name: \(.name), Age: \(.age)"'

# String manipulation
echo '{"name":"john doe"}' | jq '.name | ascii_upcase'
echo '{"name":"John Doe"}' | jq '.name | ascii_downcase'
echo '{"text":" hello "}' | jq '.text | ltrimstr(" ") | rtrimstr(" ")'

# Split and join
echo '{"path":"/home/user/file.txt"}' | jq '.path | split("/") | join("-")'

Advanced Features

Conditionals

# If-then-else
echo '{"age":30}' | jq 'if .age > 18 then "adult" else "minor" end'

# Multiple conditions
echo '{"score":85}' | jq '
 if .score >= 90 then "A"
 elif .score >= 80 then "B"
 elif .score >= 70 then "C"
 else "F"
 end'

# Null handling
echo '{"name":null}' | jq '.name // "Unknown"'

Grouping

# Group by field
echo '[{"name":"John","dept":"IT"},{"name":"Jane","dept":"HR"},{"name":"Bob","dept":"IT"}]' | jq 'group_by(.dept)'

# Group and count
echo '[{"type":"A"},{"type":"B"},{"type":"A"},{"type":"C"}]' | jq 'group_by(.type) | map({type: .[0].type, count: length})'

Aggregation

# Sum values
echo '[1,2,3,4,5]' | jq 'add'

# Min/max
echo '[1,5,3,9,2]' | jq 'min'
echo '[1,5,3,9,2]' | jq 'max'

# Average
echo '[1,2,3,4,5]' | jq 'add / length'

# Count
echo '[{"active":true},{"active":false},{"active":true}]' | jq 'map(select(.active)) | length'

Working with Complex Data

Nested Objects

# Deep field access
echo '{"user":{"profile":{"name":"John"}}}' | jq '.user.profile.name'

# Safe navigation
echo '{"user":{"profile":{"name":"John"}}}' | jq '.user.profile.email?'

# Recursive descent
echo '{"a":{"b":{"c":1}}}' | jq '.. | numbers'

Array of Objects

# Extract specific fields
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq 'map(.name)'

# Filter and transform
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq 'map(select(.age > 25) | .name)'

# Create lookup table
echo '[{"id":1,"name":"John"},{"id":2,"name":"Jane"}]' | jq 'map({(.id|tostring): .name}) | add'

Flattening

# Flatten array
echo '[[1,2],[3,4],[5,6]]' | jq 'flatten'

# Flatten one level
echo '[[1,2],[3,4],[5,6]]' | jq 'flatten(1)'

# Flatten objects
echo '{"a":{"x":1,"y":2},"b":{"x":3,"y":4}}' | jq 'to_entries | map(.value) | flatten'

Input/Output Formats

Raw Output

# Raw strings
echo '{"name":"John"}' | jq -r '.name'

# Multiple raw strings
echo '[{"name":"John"},{"name":"Jane"}]' | jq -r '.[] | .name'

# Tab-separated values
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq -r '.[] | [.name, .age] | @tsv'

CSV Output

# CSV format
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq -r '.[] | [.name, .age] | @csv'

# CSV with headers
echo '[{"name":"John","age":30},{"name":"Jane","age":25}]' | jq -r '["name","age"], (.[] | [.name, .age]) | @csv'

JSON Lines

# Convert to JSON Lines
echo '[{"name":"John"},{"name":"Jane"}]' | jq -c '.[]'

# Convert from JSON Lines
echo '{"name":"John"}
{"name":"Jane"}' | jq -s '.'

Practical Examples

API Response Processing

# Extract user names from API response
curl -s https://api.github.com/users | jq '.[].login'

# Get specific fields
curl -s https://api.github.com/users | jq '.[] | {name: .login, url: .html_url}'

# Filter by criteria
curl -s https://api.github.com/users | jq '.[] | select(.type == "User") | .login'

Log Processing

# Parse JSON logs
cat application.log | jq 'select(.level == "ERROR") | .message'

# Count by log level
cat application.log | jq -r '.level' | sort | uniq -c

# Extract timestamp and message
cat application.log | jq -r '"\(.timestamp): \(.message)"'

Configuration Management

# Update configuration
echo '{"database":{"host":"localhost","port":5432}}' | jq '.database.host = "newhost"'

# Merge configurations
echo '{"a":1,"b":2}' | jq '. + {"c":3,"d":4}'

# Remove sensitive data
echo '{"user":"john","password":"secret","email":"john@example.com"}' | jq 'del(.password)'

Data Validation

# Check required fields
echo '{"name":"John","age":30}' | jq 'if has("name") and has("age") then "valid" else "invalid" end'

# Validate data types
echo '{"name":"John","age":"30"}' | jq 'if (.name | type) == "string" and (.age | type) == "number" then "valid" else "invalid" end'

# Check array length
echo '{"items":[1,2,3]}' | jq 'if (.items | length) > 0 then "has items" else "empty" end'

Error Handling

# Optional field access
echo '{"user":{"name":"John"}}' | jq '.user.email?'

# Default values
echo '{"user":{"name":"John"}}' | jq '.user.email // "not provided"'

# Try-catch alternative
echo '{"user":{"name":"John"}}' | jq '.user.email | select(. != null)'

Empty Handling

# Handle empty arrays
echo '[]' | jq 'if length > 0 then .[0] else "empty" end'

# Handle null values
echo '{"name":null}' | jq '.name | if . == null then "N/A" else . end'

# Compact output (remove nulls)
echo '{"a":1,"b":null,"c":3}' | jq 'compact'

Command-line Options

Common Options

# Compact output
jq -c '.'

# Raw output
jq -r '.name'

# Sort keys
jq -S '.'

# Slurp mode (read entire input)
jq -s '.'

# Read from file
jq '.' data.json

# Multiple inputs
jq -s '.[0] + .[1]' file1.json file2.json

Output Control

# Tab output
jq -t '.'

# Null input
jq -n '{name: "John", age: 30}'

# Exit status
jq -e '.success' # Exit 0 if truthy, 1 if falsy/null

Advanced Use Cases

Stream Processing

# Process large JSON files
jq --stream '. as $item | if $item[0][0] == "users" then $item else empty end' large.json

# Streaming parser
curl -s https://api.example.com/stream | jq --stream

Custom Functions

# Define function
jq '
def double: . * 2;
def square: . * .;
[1,2,3,4] | map(double | square)
'

# Function with parameters
jq '
def multiply(n): . * n;
[1,2,3,4] | map(multiply(5))
'

Complex Transformations

# Pivot data
echo '[{"name":"John","skill":"Java"},{"name":"John","skill":"Python"},{"name":"Jane","skill":"JavaScript"}]' | jq '
group_by(.name) | map({
 name: .[0].name,
 skills: map(.skill)
})
'

# Nested grouping
echo '[{"dept":"IT","name":"John","salary":50000},{"dept":"IT","name":"Jane","salary":60000}]' | jq '
group_by(.dept) | map({
 department: .[0].dept,
 employees: map({name, salary}),
 total_salary: map(.salary) | add
})
'

Performance Tips

Optimization

# Use streaming for large files
jq --stream '. | select(.[0][0] == "target_field")'

# Limit output early
jq 'limit(10; .[] | select(.active))'

# Use compact output for smaller files
jq -c '.'

Memory Management

# Process line by line
jq --stream '. | select(length == 2)'

# Avoid loading entire file
jq -c '.[]' large.json | head -100

Quick Reference

Basic Syntax

. # Identity (entire input)
.field # Field access
.[0] # Array index
.[] # Array/object values
.[1:3] # Array slice
.field? # Optional field access

Common Operations

length # Get length
keys # Get keys
values # Get values
type # Get type
empty # Empty value
map(expr) # Transform array
select(expr) # Filter
has("key") # Check key existence

String Functions

ascii_downcase # Lowercase
ascii_upcase # Uppercase
ltrimstr(s) # Left trim
rtrimstr(s) # Right trim
split(s) # Split string
join(s) # Join array
test(regex) # Test regex

Math Functions

add # Sum array
min # Minimum
max # Maximum
sort # Sort array
reverse # Reverse array
unique # Unique elements
group_by(expr) # Group by expression

Troubleshooting

Common Errors

# Parse error
echo 'invalid json' | jq '.'
# Solution: Fix JSON syntax

# Field doesn't exist
echo '{"name":"John"}' | jq '.age'
# Solution: Use .age? or .age // "default"

# Type error
echo '{"name":"John"}' | jq '.name + 1'
# Solution: Convert types or check type first

Debugging

# Debug mode
jq --debug '.'

# Verbose output
jq -v '.'

# Show parse tree
jq --debug '.' 2>&1 | head -20

Nginx

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Nginx (pronounced “Engine X”) is a high-performance HTTP and reverse proxy server, mail proxy server, and generic TCP/UDP proxy server created by Igor Sysoev in 2004. Originally developed to solve the C10K problem (handling 10,000 concurrent connections), Nginx has become one of the most popular web servers in the world.

Why Use Nginx?

High Performance: Event-driven architecture handles thousands of concurrent connections with minimal memory usage
Low Resource Usage: Significantly less memory consumption compared to Apache
Reverse Proxy Excellence: Outstanding performance as a reverse proxy and load balancer
Static Content: Extremely efficient at serving static files (HTML, CSS, JS, images)
Scalability: Handles high traffic loads with ease
Flexibility: Can function as web server, reverse proxy, load balancer, HTTP cache, and mail proxy
Security: Regular security updates and robust security features
Configuration: Simple, readable configuration syntax

Key Features

Event-driven architecture: Asynchronous, non-blocking I/O
Master/Worker process model: Efficient resource management
Hot configuration reload: Zero-downtime configuration updates
SSL/TLS termination: Built-in SSL/TLS support with modern protocols
HTTP/2 and HTTP/3 support: Latest HTTP protocol implementations
Compression: Built-in gzip and Brotli compression
Caching: Advanced caching capabilities for improved performance
Rate limiting: Built-in protection against abuse and DDoS attacks

Nginx powers some of the world’s largest websites including Netflix, Cloudflare, and WordPress.com, making it an excellent choice for serving static content, load balancing, and reverse proxying.

Podman

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Podman is a daemonless, rootless container engine for developing, managing, and running OCI containers. It’s designed as a drop-in replacement for Docker with enhanced security features and Kubernetes compatibility.

Installation

Linux

# Ubuntu/Debian
sudo apt update
sudo apt install podman

# CentOS/RHEL/Fedora
sudo dnf install podman

# Arch Linux
sudo pacman -S podman

# From source
git clone https://github.com/containers/podman.git
cd podman
make
sudo make install

macOS

# Using Homebrew
brew install podman

# Initialize and start machine
podman machine init
podman machine start

# Verify installation
podman version

Windows

# Using Chocolatey
choco install podman

# Using Scoop
scoop install podman

# Initialize machine
podman machine init
podman machine start

Basic Commands

Container Management

# Run container
podman run hello-world
podman run -it ubuntu:latest /bin/bash

# List containers
podman ps # Running containers
podman ps -a # All containers

# Start/stop containers
podman start container_name
podman stop container_name
podman restart container_name

# Remove containers
podman rm container_name
podman rm -f container_name # Force remove

Image Management

# Pull images
podman pull ubuntu:latest
podman pull docker.io/nginx:alpine

# List images
podman images
podman image ls

# Remove images
podman rmi image_name
podman rmi -f image_name # Force remove

# Build images
podman build -t my-app .
podman build -f Dockerfile.prod -t my-app:prod .

Registry Operations

# Login to registry
podman login registry.example.com
podman login docker.io

# Push images
podman push my-app:latest registry.example.com/my-app:latest

# Search images
podman search nginx
podman search --limit 10 python

Advanced Container Operations

Running Containers

# Run with port mapping
podman run -p 8080:80 nginx

# Run with volume mounting
podman run -v /host/path:/container/path nginx

# Run with environment variables
podman run -e ENV_VAR=value nginx

# Run in detached mode
podman run -d --name web-server nginx

# Run with resource limits
podman run --memory=1g --cpus=0.5 nginx

Container Networking

# Create network
podman network create mynetwork

# List networks
podman network ls

# Run container on specific network
podman run --network mynetwork nginx

# Connect container to network
podman network connect mynetwork container_name

# Disconnect from network
podman network disconnect mynetwork container_name

Volume Management

# Create volume
podman volume create myvolume

# List volumes
podman volume ls

# Inspect volume
podman volume inspect myvolume

# Use volume with container
podman run -v myvolume:/data nginx

# Remove volume
podman volume rm myvolume

Pods

Pod Management

# Create pod
podman pod create --name mypod

# Create pod with port mapping
podman pod create --name mypod -p 8080:80

# List pods
podman pod ls

# Add container to pod
podman run -dt --pod mypod nginx
podman run -dt --pod mypod redis

# Start/stop pod
podman pod start mypod
podman pod stop mypod

# Remove pod
podman pod rm mypod
podman pod rm -f mypod # Force remove

Pod Networking

# Create pod with custom network
podman pod create --name mypod --network mynetwork

# Pod with multiple ports
podman pod create --name mypod -p 8080:80 -p 3000:3000

# Pod with shared volumes
podman pod create --name mypod -v /host/data:/shared

Kubernetes Integration

Generate Kubernetes YAML

# Generate pod YAML
podman generate kube mypod > mypod.yaml

# Generate deployment YAML
podman generate kube --type deployment mypod > deployment.yaml

# Generate service YAML
podman generate kube --service mypod > service.yaml

Play Kubernetes YAML

# Deploy from YAML
podman play kube deployment.yaml

# Deploy with custom name
podman play kube --name custom-name deployment.yaml

# Remove deployment
podman play kube --down deployment.yaml

Rootless Containers

Rootless Setup

# Install rootless dependencies
sudo apt install slirp4netns fuse-overlayfs

# Configure user namespaces
echo 'user.max_user_namespaces=28633' | sudo tee -a /etc/sysctl.d/userns.conf

# Set up subuid/subgid
sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER

# Enable lingering
sudo loginctl enable-linger $USER

Rootless Operations

# Run rootless container
podman run --rm -it ubuntu:latest

# Check rootless status
podman info | grep -i root

# Run with different user
podman run --user 1000:1000 nginx

# Map user namespace
podman run --userns=keep-id nginx

Security Features

Security Options

# Run with SELinux labels
podman run --security-opt label=level:s0:c123,c456 nginx

# Run with seccomp profile
podman run --security-opt seccomp=unconfined nginx

# Run with AppArmor profile
podman run --security-opt apparmor=docker-default nginx

# Run with no-new-privileges
podman run --security-opt no-new-privileges nginx

Capabilities

# Drop capabilities
podman run --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

# Add capabilities
podman run --cap-add SYS_ADMIN nginx

# Run privileged
podman run --privileged nginx

Build Images

Dockerfile

FROM ubuntu:latest

RUN apt-get update && apt-get install -y nginx

COPY nginx.conf /etc/nginx/nginx.conf
COPY . /var/www/html/

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Build Commands

# Build image
podman build -t myapp .

# Build with build args
podman build --build-arg VERSION=1.0 -t myapp .

# Build with different file
podman build -f Dockerfile.prod -t myapp:prod .

# Build with context
podman build -t myapp /path/to/context

# Multi-stage build
podman build --target production -t myapp:prod .

Container Inspection

Inspect Commands

# Inspect container
podman inspect container_name

# Inspect image
podman inspect image_name

# Get specific info
podman inspect --format='{{.NetworkSettings.IPAddress}}' container_name

# View logs
podman logs container_name
podman logs -f container_name # Follow logs
podman logs --since=1h container_name

# View processes
podman top container_name

Statistics

# Container stats
podman stats container_name

# All container stats
podman stats

# System info
podman info
podman system info

# System events
podman events

Docker Compatibility

Docker Command Mapping

# Docker to Podman aliases
alias docker=podman

# Or set up podman-docker package
sudo apt install podman-docker

# Docker-compose equivalent
podman-compose up
podman-compose down

Docker Socket

# Enable podman socket
systemctl --user enable podman.socket
systemctl --user start podman.socket

# Use with docker clients
export DOCKER_HOST=unix:///run/user/$UID/podman/podman.sock

Systemd Integration

User Services

# Generate systemd unit
podman generate systemd --new --name mycontainer > ~/.config/systemd/user/mycontainer.service

# Enable and start service
systemctl --user enable mycontainer.service
systemctl --user start mycontainer.service

# Check status
systemctl --user status mycontainer.service

System Services

# Generate system service
sudo podman generate systemd --new --name mycontainer > /etc/systemd/system/mycontainer.service

# Enable and start
sudo systemctl enable mycontainer.service
sudo systemctl start mycontainer.service

Compose Alternative

Podman Compose

# Install podman-compose
pip install podman-compose

# Or use docker-compose with podman
sudo ln -s /usr/bin/podman /usr/bin/docker

Docker Compose File

version: '3'
services:
 web:
 image: nginx:alpine
 ports:
 - "8080:80"
 volumes:
 - ./html:/usr/share/nginx/html
 
 db:
 image: postgres:13
 environment:
 POSTGRES_DB: mydb
 POSTGRES_USER: user
 POSTGRES_PASSWORD: password
 volumes:
 - db_data:/var/lib/postgresql/data

volumes:
 db_data:

Compose Commands

# Start services
podman-compose up
podman-compose up -d

# Stop services
podman-compose down

# Build services
podman-compose build

# View logs
podman-compose logs

Registry Configuration

Registry Setup

# Configure registries
sudo vim /etc/containers/registries.conf

# Add registry
[registries.search]
registries = ['docker.io', 'registry.fedoraproject.org']

[registries.insecure]
registries = ['localhost:5000']

Private Registry

# Login to private registry
podman login registry.example.com

# Push to private registry
podman tag myapp:latest registry.example.com/myapp:latest
podman push registry.example.com/myapp:latest

# Pull from private registry
podman pull registry.example.com/myapp:latest

Troubleshooting

Common Issues

# Check system
podman info

# Check version
podman version

# Reset system
podman system reset

# Clean up
podman system prune
podman system prune -a

Storage Issues

# Check storage
podman system df

# Clean up storage
podman image prune
podman container prune
podman volume prune

Network Issues

# Reset network
podman network prune

# Check network config
podman network inspect bridge

# Restart networking
podman machine restart

Performance Optimization

Container Optimization

# Use specific tags
podman pull nginx:alpine

# Multi-stage builds
FROM node:alpine AS builder
# Build stage
FROM nginx:alpine
# Runtime stage

# Resource limits
podman run --memory=512m --cpus=0.5 nginx

Storage Optimization

# Use overlay storage
podman info | grep -i storage

# Configure storage
sudo vim /etc/containers/storage.conf

# Clean up regularly
podman system prune -a

Monitoring

Container Monitoring

# Live stats
podman stats

# Health checks
podman healthcheck run container_name

# System events
podman events --since=1h

Logging

# Container logs
podman logs container_name

# System logs
journalctl --user -u podman.service

# Log drivers
podman run --log-driver=journald nginx

Security Best Practices

Container Security

# Run as non-root
podman run --user 1000:1000 nginx

# Read-only root filesystem
podman run --read-only nginx

# Drop capabilities
podman run --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

# Use trusted images
podman pull registry.redhat.io/rhel8/nginx

Host Security

# Regular updates
sudo apt update && sudo apt upgrade

# SELinux enforcement
sudo setsebool -P container_manage_cgroup on

# Firewall rules
sudo ufw allow 8080/tcp

Quick Reference

Essential Commands

podman run # Run container
podman ps # List containers
podman images # List images
podman pull # Pull image
podman build # Build image
podman stop # Stop container
podman rm # Remove container
podman rmi # Remove image

Pod Commands

podman pod create # Create pod
podman pod ls # List pods
podman pod start # Start pod
podman pod stop # Stop pod
podman pod rm # Remove pod

System Commands

podman info # System info
podman version # Version info
podman system prune # Clean up
podman system df # Storage usage
podman events # System events

Network Commands

podman network create # Create network
podman network ls # List networks
podman network inspect # Inspect network
podman network connect # Connect container
podman network disconnect # Disconnect container

Regex

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Regular expressions (regex) are patterns used to match character combinations in strings. They’re essential for text processing, validation, searching, and data extraction across virtually all programming languages and tools.

Basic Syntax

Literal Characters

hello # Matches "hello" exactly
123 # Matches "123" exactly

Meta Characters

. # Any character except newline
^ # Start of string/line
$ # End of string/line
\ # Escape character
| # OR operator
() # Group
[] # Character class
{} # Quantifier

Character Classes

Predefined Classes

. # Any character except newline
\d # Any digit (0-9)
\D # Any non-digit
\w # Any word character (a-z, A-Z, 0-9, _)
\W # Any non-word character
\s # Any whitespace character
\S # Any non-whitespace character

Custom Classes

[abc] # Any of a, b, or c
[a-z] # Any lowercase letter
[A-Z] # Any uppercase letter
[0-9] # Any digit
[^abc] # Any character except a, b, or c
[a-zA-Z0-9] # Any alphanumeric character

Quantifiers

Basic Quantifiers

* # 0 or more
+ # 1 or more
? # 0 or 1 (optional)
{n} # Exactly n times
{n,} # n or more times
{n,m} # Between n and m times

Examples

a* # "", "a", "aa", "aaa", ...
a+ # "a", "aa", "aaa", ... (not empty)
a? # "" or "a"
a{3} # "aaa" exactly
a{2,4} # "aa", "aaa", or "aaaa"

Anchors

Position Anchors

^ # Start of string/line
$ # End of string/line
\b # Word boundary
\B # Non-word boundary

Examples

^hello # "hello" at start of line
world$ # "world" at end of line
\bcat\b # "cat" as whole word
\Bcat\B # "cat" not as whole word

Groups and Capturing

Groups

(abc) # Capture group
(?:abc) # Non-capturing group
(?P<name>abc) # Named group (Python)
(?<name>abc) # Named group (C#, Java)

Backreferences

(cat)\1 # Matches "catcat"
(\w+)\s+\1 # Matches repeated words

Common Patterns

Email Validation

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Phone Numbers

^\+?1?[-.\s]?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}$

URLs

^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$

IPv4 Address

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Date Formats

# MM/DD/YYYY
^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$

# YYYY-MM-DD
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$

Credit Card Numbers

# Visa
^4[0-9]{12}(?:[0-9]{3})?$

# MasterCard
^5[1-5][0-9]{14}$

# American Express
^3[47][0-9]{13}$

Language-Specific Usage

JavaScript

// Create regex
const regex = /pattern/flags;
const regex = new RegExp('pattern', 'flags');

// Test match
regex.test(string);

// Find matches
string.match(regex);
string.search(regex);
string.replace(regex, replacement);

Python

import re

# Compile regex
pattern = re.compile(r'regex_pattern')

# Match functions
re.match(pattern, string) # Match at beginning
re.search(pattern, string) # Find first match
re.findall(pattern, string) # Find all matches
re.sub(pattern, replacement, string) # Replace

Bash/grep

# Basic grep
grep 'pattern' file.txt

# Extended regex
grep -E 'pattern' file.txt
egrep 'pattern' file.txt

# Perl-compatible regex
grep -P 'pattern' file.txt

sed

# Replace with regex
sed 's/pattern/replacement/g' file.txt

# Extended regex
sed -E 's/pattern/replacement/g' file.txt

Flags/Modifiers

Common Flags

i # Case insensitive
g # Global (find all matches)
m # Multiline (^ and $ match line breaks)
s # Dot matches newline
x # Extended (ignore whitespace)

Examples

/hello/i # Case insensitive
/hello/g # Global search
/hello/gi # Case insensitive + global

Advanced Features

Lookahead/Lookbehind

(?=pattern) # Positive lookahead
(?!pattern) # Negative lookahead
(?<=pattern) # Positive lookbehind
(?<!pattern) # Negative lookbehind

Examples

\d+(?=px) # Numbers followed by "px"
\d+(?!px) # Numbers not followed by "px"
(?<=\$)\d+ # Numbers preceded by "$"
(?<!\$)\d+ # Numbers not preceded by "$"

Practical Examples

Extract Domain from Email

@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})

Find HTML Tags

<\/?[a-zA-Z][^>]*>

Match Quoted Strings

"([^"\\]|\\.)*"

Find CSS Colors

#[0-9a-fA-F]{3,6}

Extract URLs from Text

https?:\/\/[^\s]+

Match JSON Values

"[^"]*":\s*("[^"]*"|\d+|true|false|null)

Testing and Debugging

Online Tools

regex101.com - Interactive regex tester
regexr.com - Visual regex builder
regexpal.com - Simple regex tester

Command Line Testing

# Test with grep
echo "test string" | grep -E 'pattern'

# Test with sed
echo "test string" | sed 's/pattern/replacement/'

# Test with Python
python3 -c "import re; print(re.search(r'pattern', 'test string'))"

Performance Tips

Best Practices

Use specific characters instead of . when possible
Avoid nested quantifiers like (a+)+
Use non-capturing groups (?:...) when you don’t need the match
Anchor patterns with ^ and $ when appropriate
Use word boundaries \b for word matching

Common Pitfalls

Greedy vs Non-greedy: .* vs .*?
Backtracking: Avoid complex nested patterns
Case sensitivity: Remember to use i flag when needed
Escaping: Don’t forget to escape special characters

Quick Reference

Most Common Patterns

\d+ # One or more digits
\w+ # One or more word characters
\s+ # One or more whitespace
[a-zA-Z]+ # One or more letters
\b\w+\b # Whole words
^.+$ # Entire line
.* # Any characters (greedy)
.*? # Any characters (non-greedy)

Escape Sequences

\. # Literal dot
\* # Literal asterisk
\+ # Literal plus
\? # Literal question mark
\\ # Literal backslash
\( # Literal parenthesis
\[ # Literal bracket
\{ # Literal brace
\| # Literal pipe

Tmux

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Tmux is a terminal multiplexer that allows you to run multiple terminal sessions, windows, and panes within a single terminal window. It’s essential for remote work, development environments, and maintaining persistent sessions.

Installation

# Ubuntu/Debian
sudo apt install tmux

# macOS
brew install tmux

# CentOS/RHEL
sudo yum install tmux

# Arch Linux
sudo pacman -S tmux

Basic Concepts

Hierarchy

Session: Top-level container for windows
Window: Contains one or more panes
Pane: Individual terminal instance

Default Prefix Key

Prefix: Ctrl+b (can be customized)
All tmux commands start with the prefix key

Session Management

Creating Sessions

# Create new session
tmux new-session
tmux new

# Create named session
tmux new-session -s session_name
tmux new -s work

# Create detached session
tmux new-session -d -s background

Listing Sessions

# List all sessions
tmux list-sessions
tmux ls

# Show sessions in tmux
Ctrl+b s

Attaching to Sessions

# Attach to last session
tmux attach
tmux a

# Attach to specific session
tmux attach -t session_name
tmux a -t work

# Attach or create session
tmux new-session -A -s session_name

Detaching from Sessions

# Detach from current session
Ctrl+b d

# Detach from command line
tmux detach

Session Control

# Kill session
tmux kill-session -t session_name

# Kill all sessions
tmux kill-server

# Rename session
Ctrl+b $

Window Management

Creating Windows

# Create new window
Ctrl+b c

# Create window with name
Ctrl+b c
# Then rename: Ctrl+b ,

Navigating Windows

# Next window
Ctrl+b n

# Previous window
Ctrl+b p

# Go to window by number
Ctrl+b 0-9

# Go to window by name
Ctrl+b f

# List windows
Ctrl+b w

Window Control

# Rename window
Ctrl+b ,

# Kill window
Ctrl+b &

# Move window
Ctrl+b .

Pane Management

Creating Panes

# Split horizontally (top/bottom)
Ctrl+b "

# Split vertically (left/right)
Ctrl+b %

# Split with custom command
Ctrl+b "
# Then type command

Navigating Panes

# Move between panes
Ctrl+b arrow keys
Ctrl+b h/j/k/l # vim-style (if configured)

# Go to next pane
Ctrl+b o

# Go to previous pane
Ctrl+b ;

# Show pane numbers
Ctrl+b q

Resizing Panes

# Resize pane (arrow keys)
Ctrl+b Ctrl+arrow keys

# Resize by 5 cells
Ctrl+b Alt+arrow keys

# Make pane full screen
Ctrl+b z

# Balance panes
Ctrl+b Alt+1 # horizontal
Ctrl+b Alt+2 # vertical

Pane Control

# Kill pane
Ctrl+b x

# Break pane to new window
Ctrl+b !

# Move pane to another window
Ctrl+b :
move-pane -t window_name

# Swap panes
Ctrl+b { # swap with previous
Ctrl+b } # swap with next

Copy Mode

Entering Copy Mode

# Enter copy mode
Ctrl+b [

# Search in copy mode
Ctrl+b Ctrl+s # forward
Ctrl+b Ctrl+r # backward

# Move cursor
Arrow keys
h/j/k/l # vim-style

# Page up/down
Page Up/Page Down
Ctrl+b/Ctrl+f # vim-style

# Go to line
g # beginning
G # end

Selecting and Copying

# Start selection
Space

# Copy selection
Enter

# Paste
Ctrl+b ]

# Show paste buffer
Ctrl+b =

Command Mode

Entering Command Mode

# Command prompt
Ctrl+b :

# Common commands
:new-window
:kill-window
:split-window
:resize-pane

Useful Commands

# List commands
:list-commands

# Show key bindings
:list-keys

# Reload config
:source-file ~/.tmux.conf

# Show options
:show-options

Configuration

Basic Configuration (~/.tmux.conf)

# Change prefix key
set -g prefix C-a
unbind C-b
bind C-a send-prefix

# Enable mouse support
set -g mouse on

# Start windows and panes at 1
set -g base-index 1
setw -g pane-base-index 1

# Renumber windows
set -g renumber-windows on

# Increase history limit
set -g history-limit 10000

# Enable vi mode
setw -g mode-keys vi

# Fast pane switching
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

Status Bar Configuration

# Status bar
set -g status-interval 1
set -g status-justify centre
set -g status-style bg=black,fg=white

# Status left
set -g status-left-length 40
set -g status-left '#[fg=green]#S #[fg=blue]#I #[fg=cyan]#P'

# Status right
set -g status-right '#[fg=cyan]%d %b %R'

# Window status
setw -g window-status-style fg=cyan,bg=black
setw -g window-status-current-style fg=white,bg=red

Key Bindings

# Vim-style pane navigation
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# Vim-style copy mode
bind-key -T copy-mode-vi 'v' send -X begin-selection
bind-key -T copy-mode-vi 'y' send -X copy-selection

# Better splitting
bind | split-window -h
bind - split-window -v

Common Workflows

Development Setup

# Create development session
tmux new-session -d -s dev

# Split into multiple panes
tmux split-window -h
tmux split-window -v
tmux select-pane -t 0
tmux split-window -v

# Run different commands in each pane
tmux send-keys -t 0 'vim' Enter
tmux send-keys -t 1 'npm start' Enter
tmux send-keys -t 2 'npm test' Enter
tmux send-keys -t 3 'git status' Enter

# Attach to session
tmux attach -t dev

Remote Work

# Create persistent session on remote server
ssh user@server
tmux new-session -d -s remote-work

# Run long-running processes
tmux send-keys 'python train_model.py' Enter

# Detach and logout
tmux detach
exit

# Later: reconnect and attach
ssh user@server
tmux attach -t remote-work

Advanced Features

Session Scripting

#!/bin/bash
# Create development environment
tmux new-session -d -s dev -x 120 -y 40

# Create windows
tmux new-window -t dev:1 -n 'editor'
tmux new-window -t dev:2 -n 'server'
tmux new-window -t dev:3 -n 'tests'

# Setup editor window
tmux send-keys -t dev:1 'cd ~/project && vim' Enter

# Setup server window
tmux send-keys -t dev:2 'cd ~/project && npm start' Enter

# Setup tests window
tmux send-keys -t dev:3 'cd ~/project' Enter

# Attach to session
tmux attach -t dev

Plugins (TPM)

# Install TPM (Tmux Plugin Manager)
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

# Add to ~/.tmux.conf
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'

# Initialize TPM
run '~/.tmux/plugins/tpm/tpm'

# Install plugins: Ctrl+b I
# Update plugins: Ctrl+b U

Troubleshooting

Common Issues

Prefix key not working

Vim

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Vim is a highly configurable text editor built to make creating and changing text very efficient. It’s an improved version of the vi editor with additional features like syntax highlighting, plugin system, and extensive customization options.

Installation

# Ubuntu/Debian
sudo apt install vim

# macOS
brew install vim
# or use MacVim for GUI
brew install --cask macvim

# CentOS/RHEL
sudo yum install vim

# Arch Linux
sudo pacman -S vim

Basic Concepts

Vim operates in different modes:

Tools on QuickRef - Personal Developer Reference

CocoaPods

Overview

Installation

Basic Workflow

Podfile

KiCad

Overview

Installation

General Hotkeys

Schematic Editor Hotkeys

General

Component Manipulation

PCB Editor Hotkeys

General

Drawing

3D Viewer

Tips and Tricks

See Also

ADB (Android Debug Bridge)

Overview

Installation

Basic Commands

Device Management

File Management

App Management

Installing and Uninstalling Apps

App Information

Debugging

Logcat

Shell Access

Advanced Commands

Port Forwarding

Screenshots and Screen Recording

Quick Reference

Common Commands

See Also

Curl

Overview

Installation

Basic Usage

Simple GET Request

Download Files

HTTP Methods

GET Requests

POST Requests

PUT Requests

DELETE Requests

PATCH Requests

Headers and Authentication

Custom Headers

Authentication

Basic Authentication

Bearer Token

API Key

Data Formats

JSON Data

Form Data

Multipart Form Data

XML Data

Output and Formatting

Output Control

Response Information

Pretty Print JSON

Advanced Features

Follow Redirects

Cookies

Timeouts and Retries

Proxy Support

SSL/TLS Options

SSL Verification

SSL Information

Testing APIs

REST API Testing

GraphQL API Testing

Health Checks

Practical Examples

Download and Extract

API Testing Script

Web Scraping