Dev Fundamentals

Cross-cutting concepts every developer relies on: shells, files, networking, and data formats.

20 flashcards · select reveal or click a card to see details

shell beginner

Shell vs Terminal

The terminal is the window/app; the shell is the program inside it that interprets your commands (bash, zsh, fish).

details / example

echo $SHELL          # which shell you're running
echo $0              # current shell name
chsh -s /bin/zsh     # change default shell

macOS defaults to zsh; most Linux distros default to bash. Most bash scripts work in zsh, but advanced features differ; always declare with #!/usr/bin/env bash in scripts.

shell beginner

Environment Variables

Key-value pairs that exist in your shell’s environment and are inherited by programs you run from it.

details / example

# set for current shell
export API_KEY="sk-..."
export DATABASE_URL="postgres://..."

# use in commands
echo "$API_KEY"
curl -H "Authorization: Bearer $API_KEY" ...

# see all env vars
env
printenv API_KEY

# inline (set just for one command)
DEBUG=1 ./script.sh

Programs read env vars at startup: the standard pattern for config that varies between machines (API keys, database URLs, debug flags). export makes the variable available to child processes; without it, only the current shell sees it.

shell beginner

PATH

A colon-separated list of directories the shell searches when you type a command name.

details / example

echo "$PATH"
# /usr/local/bin:/usr/bin:/bin:/Users/felipe/.local/bin

which python          # find which one you're running
which -a python       # all matches in PATH

# add a directory (prepend)
export PATH="$HOME/bin:$PATH"

Order matters: the shell uses the first match. Prepend to override system tools. When “command not found” hits a binary you know exists, PATH is usually why.

shell beginner

Dotfiles

Hidden config files in your home directory that customize your shell, editors, and tools.

details / example

~/.zshrc           # zsh config (runs each shell)
~/.bashrc          # bash config
~/.profile         # POSIX, runs at login
~/.gitconfig       # git settings
~/.ssh/config      # ssh client config

# apply changes without restarting
source ~/.zshrc

Put export VAR=..., aliases, and functions in ~/.zshrc (or ~/.bashrc). After editing, run source to reload, or just open a new terminal.

shell beginner

Home & Working Directory

~ expands to your home dir; . is current; .. is parent. The shell tracks a current working directory (cwd).

details / example

pwd                    # /Users/felipe/projects/api
cd ~                   # home
cd ~/Documents         # absolute via home
cd ../sibling-dir      # relative
cd -                   # previous dir

Scripts often misbehave when run from a different working directory. To anchor a script to its own location, put cd "$(dirname "$0")" at the top.

files beginner

File Permissions

Every file has read/write/execute bits for owner, group, and others, totaling 9 permission bits.

details / example

ls -l script.sh
# -rwxr-xr-x  1 felipe  staff  512 Jan 15  script.sh
#  ─── ─── ───
# owner grp other

chmod +x script.sh           # make executable
chmod 644 file.txt           # rw-r--r--
chmod 755 script.sh          # rwxr-xr-x
chmod 600 ~/.ssh/id_ed25519  # owner-only (required)

644 for normal files, 755 for executables and dirs, 600 for secrets. SSH keys especially must be 600; SSH refuses to use them otherwise.

files beginner

Hidden Files

Files starting with . are hidden from ls by default, used for config and metadata.

details / example

ls            # excludes hidden
ls -a         # all (incl. hidden)
ls -la        # long format + hidden

# common ones
.env          # local env vars
.gitignore    # git ignore patterns
.vscode/      # editor config
.DS_Store     # macOS metadata (annoying)

Most secret files (.env, SSH keys) are dotfiles by convention. Add system noise like .DS_Store to a global gitignore so it never sneaks into commits.

files beginner

Absolute vs Relative Paths

Absolute paths start from /; relative paths start from your current working directory.

details / example

/etc/hosts             # absolute: same anywhere
./config.json          # relative: depends on cwd
../shared/lib          # parent + descend
~/.config              # home-relative

# in a script: anchor to script's directory
cd "$(dirname "$0")"

Relative paths break when scripts are invoked from elsewhere. Cron, systemd, and CI all run from unexpected directories; always use absolute paths or anchor the script’s location.

network beginner

localhost & Ports

localhost (127.0.0.1) is your own machine; ports identify which program receives the connection.

details / example

# standard local URLs
http://localhost:3000        # web dev server
http://127.0.0.1:8080        # equivalent

# what's listening?
lsof -i :3000                # who has port 3000?
lsof -i -P -n | grep LISTEN  # all listening

# kill the process holding a port
lsof -ti :3000 | xargs kill

Common dev ports: 3000 (Node/React), 5173 (Vite), 8000/8080 (general), 5432 (Postgres), 6379 (Redis). When you see “address already in use”, another process owns that port.

network beginner

HTTP Methods & Status Codes

HTTP verbs declare intent; status codes signal the result.

details / example

# methods
GET     /users         # read
POST    /users         # create
PUT     /users/42      # replace
PATCH   /users/42      # partial update
DELETE  /users/42      # remove

# status code categories
2xx  success      (200 OK, 201 Created, 204 No Content)
3xx  redirect    (301 Moved, 304 Not Modified)
4xx  client err  (400 Bad Request, 401, 403, 404)
5xx  server err  (500, 502 Bad Gateway, 503)

When debugging APIs, the status code’s first digit tells you whose problem it is: 4xx means your request was bad, 5xx means the server failed.

network beginner

curl Basics

The standard tool for making HTTP requests from the command line.

details / example

curl https://api.example.com/users     # GET
curl -i https://...                    # include headers
curl -s https://...                    # silent (no progress)

curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"name": "Felipe"}'

# download to file
curl -o output.json https://...

-s for clean output you can pipe to jq. -i to debug headers. For repeated/complex requests, save to a script or use httpie for friendlier syntax.

network beginner

SSH Keys

A key pair lets you authenticate to remote servers (and GitHub) without passwords.

details / example

# generate a modern key
ssh-keygen -t ed25519 -C "you@example.com"
# → ~/.ssh/id_ed25519       (private, keep secret)
# → ~/.ssh/id_ed25519.pub   (public, share freely)

# show the public key (paste into GitHub)
cat ~/.ssh/id_ed25519.pub

# use a specific key
ssh -i ~/.ssh/id_ed25519 user@host

# test GitHub connection
ssh -T git@github.com

Share the .pub (public) key, never the private one. The private key file must be chmod 600 or SSH refuses to use it.

data beginner

JSON

The standard data format for APIs and config: strings, numbers, booleans, null, arrays, objects.

details / example

{
  "name": "Felipe",
  "age": 30,
  "active": true,
  "tags": ["admin", "ops"],
  "address": null
}

# validate / pretty-print
cat data.json | jq .

# in Python
import json
data = json.loads(raw_string)

Strict syntax: keys are always quoted strings, no trailing commas, no comments. When an API returns malformed JSON, jq is the fastest way to spot it.

data beginner

YAML

Human-friendly config format used heavily in DevOps tools (Docker Compose, Kubernetes, GitHub Actions).

details / example

name: my-app
version: 1.0
active: true

tags:
  - admin
  - ops

config:
  host: localhost
  port: 8080

Indentation defines structure: use spaces, never tabs. Whitespace bugs are the #1 cause of YAML errors. Validate with yq or a linter before committing.

data beginner

Text Encoding

How characters are stored as bytes. UTF-8 is the standard everywhere modern.

details / example

# check encoding
file -I data.txt
# → data.txt: text/plain; charset=utf-8

# convert if needed
iconv -f ISO-8859-1 -t UTF-8 old.txt > new.txt

# in Python (default is UTF-8)
with open("file.txt", encoding="utf-8") as f:
    content = f.read()

Default to UTF-8 everywhere. You’ll mostly hit encoding issues with old files or Windows-exported data; iconv converts between encodings.

data beginner

Line Endings

Text files end lines differently across systems: Unix uses LF (\n), Windows uses CRLF (\r\n).

details / example

# check
file script.sh
# → ASCII text                     (good: LF)
# → ASCII text, with CRLF endings  (Windows)

# convert
dos2unix script.sh

# git auto-handle
git config --global core.autocrlf input    # macOS/Linux

CRLF in shell scripts breaks them silently (bash: cannot execute: required file not found). Set git’s core.autocrlf so checkouts use the right convention for your OS.

workflows intermediate

Set Up Environment Variables

Move secrets and per-machine config out of code and into env vars or a .env file. The standard pattern across every language.

details / example

# 1. Permanent: add to ~/.zshrc or ~/.bashrc
export OPENAI_API_KEY="sk-..."
export DATABASE_URL="postgres://localhost/myapp"
# then: source ~/.zshrc

# 2. Per-project: .env file (don't commit!)
# .env
OPENAI_API_KEY=sk-...
DATABASE_URL=postgres://localhost/myapp

# load it (bash)
set -a; source .env; set +a

# in Python (with python-dotenv)
from dotenv import load_dotenv
load_dotenv()
api_key = os.environ["OPENAI_API_KEY"]

# always: add to .gitignore
echo ".env" >> .gitignore

User-wide secrets go in your shell rc file. Project-specific config goes in .env; never commit it. Commit a .env.example with the keys (no values) so teammates know what to set.

workflows intermediate

Set Up SSH Keys for GitHub

Configure password-less authentication for git operations against GitHub. One-time setup that saves friction forever.

details / example

# 1. Generate the key
ssh-keygen -t ed25519 -C "you@example.com"

# 2. Copy the public key to clipboard
pbcopy < ~/.ssh/id_ed25519.pub        # macOS
cat ~/.ssh/id_ed25519.pub             # Linux: copy manually

# 3. Add it on GitHub:
#    Settings → SSH and GPG keys → New SSH key

# 4. Test it
ssh -T git@github.com
# → Hi felipe! You've successfully authenticated.

# 5. Clone via SSH (not HTTPS)
git clone git@github.com:user/repo.git

SSH avoids the periodic password/token prompts you get with HTTPS. For multiple GitHub accounts (work + personal), use ~/.ssh/config to map hosts to specific keys.

workflows intermediate

Find What's Running on a Port

A common debugging task: figuring out which process owns a port and freeing it.

details / example

# who's on port 3000?
lsof -i :3000
# COMMAND   PID    USER   ...
# node     12345  felipe ...

# alternatives
netstat -anv | grep 3000     # macOS
ss -tulpn | grep 3000        # Linux

# kill it (gentle, sends SIGTERM)
kill 12345

# kill it (force, sends SIGKILL)
kill -9 12345

# one-liner: kill whatever's on a port
lsof -ti :3000 | xargs kill

After a crashed dev server you’ll often see “address already in use”. This is the fix. Try kill (SIGTERM) first; only escalate to kill -9 (SIGKILL) if the process won’t stop.

workflows intermediate

Manage Tool Versions

Different projects often need different versions of Python, Node, etc. Version managers handle this without polluting your system.

details / example

# Python: uv handles versions natively
uv python install 3.12
uv python install 3.11
uv python list                # what's available
uv python pin 3.12            # writes .python-version

# Node.js: fnm or nvm
fnm install 20
fnm use 20
fnm default 20

# check what's active
python --version
node --version

Avoid installing language runtimes directly through brew or apt for development; version conflicts will bite you. Use uv (Python), fnm/nvm (Node), or asdf (multi-language) and let project files declare which version to use.