# Dev Basics & Tools Intro | Beginner Cheatsheet

> Your first-stop orientation: how to navigate your IDE, understand file formats, use spreadsheets for data, deploy a site in minutes, and discover the essential online tools every data practitioner uses daily.

---

## 1. VS Code Your Main IDE

VS Code (Visual Studio Code) is the most widely used code editor. Free, open-source, and runs on Mac/Windows/Linux.

### The 5 Panels

```
┌──────────────────────────────────────────────────────────┐
│  Activity Bar │  Explorer / Editor │  Terminal (bottom)  │
│  (left strip) │   (centre pane)    │                     │
│               │                    │                     │
│   Explorer    │  your files here   │  $ python app.py    │
│   Search      │                    │                     │
│   Source      │                    │                     │
│   Extensions  │                    │                     │
└──────────────────────────────────────────────────────────┘
```

| Panel | Shortcut | What it does |
| :--- | :--- | :--- |
| **Explorer** | `Ctrl/Cmd + Shift + E` | Browse & open files/folders |
| **Search** | `Ctrl/Cmd + Shift + F` | Find text across all files |
| **Source Control** | `Ctrl/Cmd + Shift + G` | Git: stage, commit, push |
| **Extensions** | `Ctrl/Cmd + Shift + X` | Install language support, themes |
| **Terminal** | `Ctrl/Cmd + `` ` `` | Integrated terminal (bash/zsh/cmd) |

### Most Used Keyboard Shortcuts

| Action | Mac | Windows/Linux |
| :--- | :--- | :--- |
| **Command Palette** (run any command) | `Cmd + Shift + P` | `Ctrl + Shift + P` |
| **Quick Open** (jump to file by name) | `Cmd + P` | `Ctrl + P` |
| **New terminal** | `Ctrl + `` ` `` | `Ctrl + `` ` `` |
| **Save file** | `Cmd + S` | `Ctrl + S` |
| **Save all** | `Cmd + Option + S` | `Ctrl + K, S` |
| **Find in file** | `Cmd + F` | `Ctrl + F` |
| **Find & replace** | `Cmd + H` | `Ctrl + H` |
| **Duplicate line** | `Opt + Shift + ↓` | `Alt + Shift + ↓` |
| **Move line up/down** | `Opt + ↑/↓` | `Alt + ↑/↓` |
| **Multi-cursor** | `Opt + Click` | `Alt + Click` |
| **Toggle comment** | `Cmd + /` | `Ctrl + /` |
| **Format document** | `Shift + Opt + F` | `Shift + Alt + F` |
| **Go to definition** | `F12` | `F12` |
| **Zen mode** (distraction-free) | `Cmd + K, Z` | `Ctrl + K, Z` |
| **Split editor** | `Cmd + \` | `Ctrl + \` |

### Essential Extensions for Data Science

```
Install via: Ctrl/Cmd + Shift + X → search name → Install

Must-haves:
  Python              → language support, IntelliSense, linting
  Pylance             → fast type checking & autocomplete
  Jupyter             → run .ipynb notebooks inside VS Code
  GitLens             → see git blame, history inline
  Prettier            → auto-format HTML/CSS/JS/JSON
  indent-rainbow      → colour-code indentation levels
  Error Lens          → show errors inline (not just in Problems panel)
  Thunder Client      → lightweight API testing (like Postman, inside VS Code)

Themes (cosmetic but helps focus):
  One Dark Pro        → popular dark theme
  Catppuccin          → soft pastel dark theme
  Tokyo Night         → blue-toned dark theme
```

### Opening a Project

```bash
# From terminal : opens VS Code in current folder
code .

# Or: File → Open Folder → select your project directory
# Once open, the Explorer shows all files on the left
```

### The Command Palette (Most Powerful Feature)

Press `Cmd/Ctrl + Shift + P` and type anything:

```
> Python: Select Interpreter     → choose which Python/venv to use
> Format Document                → auto-format current file
> Git: Clone                     → clone a repo by URL
> Toggle Integrated Terminal     → show/hide terminal
> Preferences: Open Settings     → open settings.json
> Live Server: Open with...      → start local server for HTML files
> Jupyter: Create New Notebook   → new .ipynb file
```

---

## 2. AI IDEs & Coding Assistants

These tools understand your codebase and help you write, explain, and debug code using AI.

### VS Code with GitHub Copilot

```
Install: Extensions → search "GitHub Copilot" → Install
Requires: GitHub account + Copilot subscription (free for students)

Usage:
  - Start typing → Copilot suggests completions (press Tab to accept)
  - Write a comment describing what you want → Copilot writes the code
  - Select code + Cmd/Ctrl+I → Copilot Chat panel to ask questions
  - /fix, /explain, /tests  → slash commands in chat
```

### Cursor : AI-First IDE

Cursor is a fork of VS Code with AI deeply built in. Looks identical to VS Code but with superpowers.

```
Download: cursor.com (free tier available)

Key features VS Code doesn't have:
  Cmd/Ctrl + K      → Edit selected code with AI (describe what to change)
  Cmd/Ctrl + L      → Chat panel with full codebase context
  Cmd/Ctrl + I      → Composer : multi-file edits from one prompt
  @ mentions        → @file, @folder, @codebase, @docs to add context
  Apply from chat   → AI writes code in chat → click Apply → goes into file

All VS Code shortcuts and extensions work identically.
```

### Windsurf : Agentic IDE by Codeium

```
Download: codeium.com/windsurf (free)
Similar to Cursor. Key differentiator: "Cascade" agent that autonomously
edits multiple files, runs commands, fixes its own errors.
```

### Claude Code : Terminal AI Coder

```
Install: npm install -g @anthropic-ai/claude-code
Run:     claude  (in any project directory)

Reads your entire codebase, writes and edits files, runs commands.
Best for: complex multi-file tasks from a description.
```

### Comparison

| Tool | Best for | Cost |
| :--- | :--- | :--- |
| VS Code + Copilot | Autocomplete while typing | Free for students |
| Cursor | Full codebase AI chat + edits | Free tier, $20/mo pro |
| Windsurf | Agentic autonomous edits | Free tier |
| Claude Code | Terminal-based full project tasks | Anthropic API cost |
| Google Colab | Python notebooks in browser (no install) | Free ❌ GPU limits |

---

## 3. File Formats Every Developer Must Know

### CSV : Comma-Separated Values

```
Plain text table. Each line = one row. Columns separated by commas.

name,age,city,salary
Alice,30,Mumbai,90000
Bob,25,Delhi,75000
Carol,35,Bangalore,110000

Rules:
  - First row is usually the header (column names)
  - Values with commas must be quoted: "Smith, John"
  - Values with quotes: double them → "He said ""hello"""
  - Encoding: always use UTF-8 to avoid emoji/language issues
  - Line endings: Unix (\n) preferred over Windows (\r\n)

Read in Python:
  import csv
  with open('data.csv') as f:
      reader = csv.DictReader(f)
      for row in reader:
          print(row['name'], row['age'])

  # Or with pandas (easier):
  import pandas as pd
  df = pd.read_csv('data.csv')
```

### JSON : JavaScript Object Notation

```json
{
  "name": "Alice",
  "age": 30,
  "active": true,
  "score": 9.5,
  "tags": ["python", "ml", "data"],
  "address": {
    "city": "Mumbai",
    "pin": "400001"
  },
  "notes": null
}
```

```
JSON Types:
  string  → "hello"              must use double quotes ✔
  number  → 42  or  3.14
  boolean → true  /  false       lowercase only ✔
  array   → ["a", "b", "c"]
  object  → {"key": "value"}
  null    → null

Common mistakes:
  'single quotes'   → INVALID ✘
  trailing comma    → {"a":1,}  INVALID ✘ (Python dicts allow it, JSON doesn't)
  comments          → // or /* */ INVALID ✘

Read/Write in Python:
  import json

  # Parse JSON string → Python dict
  data = json.loads('{"name": "Alice", "age": 30}')
  print(data['name'])   # Alice

  # Read JSON file
  with open('data.json') as f:
      data = json.load(f)

  # Write Python dict → JSON file
  with open('output.json', 'w') as f:
      json.dump(data, f, indent=2)

  # Pretty-print
  print(json.dumps(data, indent=2))
```

### YAML : Human-Readable Config

YAML is used for config files (GitHub Actions, Docker Compose, FastAPI settings).

```yaml
# Comments with #
name: My Project
version: 1.0.0
debug: false

database:
  host: localhost
  port: 5432
  name: mydb

allowed_origins:
  - https://myapp.com
  - http://localhost:3000

features:
  dark_mode: true
  max_users: 100
```

```python
import yaml

with open('config.yaml') as f:
    config = yaml.safe_load(f)   # safe_load prevents code execution ✔

print(config['database']['host'])   # localhost
```

### TOML : Config for Python Projects

Used in `pyproject.toml` (modern Python packaging), `Cargo.toml` (Rust).

```toml
[project]
name = "my-app"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = ["fastapi", "pandas", "pydantic"]

[tool.ruff]
line-length = 88
```

### File Format Decision

```
Data to share/store?          → Parquet (typed, compressed) or CSV (human-readable)
API request/response?         → JSON
Config files?                 → YAML (complex nesting) or TOML (Python projects)
Tabular data for humans?      → Excel (.xlsx) or CSV
Large dataset (>100MB)?       → Parquet, never CSV
```

---

## 4. Excel & Google Sheets for Data Work

Both work the same way. Google Sheets is cloud-based (free); Excel is local (Microsoft 365).

### Essential Keyboard Shortcuts

| Action | Shortcut |
| :--- | :--- |
| Select entire column | `Ctrl + Space` |
| Select entire row | `Shift + Space` |
| Select to last cell with data | `Ctrl + Shift + End` |
| Fill down (copy formula down) | `Ctrl + D` |
| Fill right | `Ctrl + R` |
| Auto-sum selected range | `Alt + =` |
| Format as table (Excel) | `Ctrl + T` |
| Find & Replace | `Ctrl + H` |
| Insert row/column | `Ctrl + Shift + +` |
| Freeze panes (keep headers visible) | View → Freeze |

### Must-Know Functions

```excel
= SUM(B2:B100)              → add all values in column B
= AVERAGE(B2:B100)          → mean
= COUNT(B2:B100)            → count numeric cells
= COUNTA(A2:A100)           → count non-empty cells
= MAX(B2:B100)              → largest value
= MIN(B2:B100)              → smallest value

= IF(B2 > 1000, "High", "Low")          → conditional
= IF(A2="", "missing", A2)             → handle empty cells

= COUNTIF(C2:C100, "India")            → count rows where country = India
= COUNTIF(B2:B100, ">50000")           → count rows where salary > 50000
= SUMIF(C2:C100, "India", B2:B100)     → sum salary where country = India

= VLOOKUP(E2, A:B, 2, FALSE)           → look up E2 in column A, return column B
= XLOOKUP(E2, A:A, B:B)               → modern VLOOKUP (Google Sheets + Excel 365) ✔

= TRIM(A2)                             → remove leading/trailing spaces ✔
= LOWER(A2)                            → lowercase
= UPPER(A2)                            → UPPERCASE
= LEN(A2)                              → character count
= LEFT(A2, 3)                          → first 3 characters
= SUBSTITUTE(A2, " ", "_")            → replace spaces with underscores
= TEXT(B2, "YYYY-MM-DD")             → format date as string

= UNIQUE(A2:A100)                      → list unique values (Google Sheets / Excel 365)
= FILTER(A2:C100, C2:C100="India")    → rows where country = India ✔
= SORT(A2:B100, 2, FALSE)             → sort by col 2 descending
```

### Pivot Tables : Summarise Data Instantly

```
1. Select your data range (including headers)
2. Insert → Pivot Table
3. Drag fields:
     Rows    → what to group by (e.g. Country, Department)
     Columns → optional second grouping
     Values  → what to calculate (SUM, COUNT, AVERAGE of salary)
     Filters → optional filter (e.g. only 2024)

Pivot tables answer: "What's the total sales per country per month?"
without writing a single formula.
```

### Export CSV from Sheets/Excel

```
Google Sheets:  File → Download → Comma-separated values (.csv)
Excel:          File → Save As → CSV (Comma delimited) .csv

Warning: Excel sometimes saves as Windows-1252 encoding.
In pandas: pd.read_csv('file.csv', encoding='latin-1')  if UTF-8 fails.
```

### Google Sheets Unique Features

```python
# Read Google Sheet directly in Python (make sheet public first)
import pandas as pd

sheet_id = "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgVE2upms"
url = f"https://docs.google.com/spreadsheets/d/{sheet_id}/export?format=csv"
df = pd.read_csv(url)

# Or use gspread for authenticated access
import gspread
from google.oauth2.service_account import Credentials

creds = Credentials.from_service_account_file('credentials.json',
        scopes=['https://spreadsheets.google.com/feeds'])
gc = gspread.authorize(creds)
sh = gc.open("My Sheet")
df = pd.DataFrame(sh.sheet1.get_all_records())
```

---

## 5. Deploying Your Project : Quick Start

> For deep Docker/CI/CD coverage → see [Deployment & DevOps](deployment). This section covers one-click/Git-push deploys for beginners.

### Vercel : Best for Static Sites & Next.js

```
What: Deploys frontend projects (HTML/CSS/JS, React, Next.js, Vue)
Free tier: Unlimited personal projects, custom domain, HTTPS

Steps:
  1. Push project to GitHub
  2. Go to vercel.com → "New Project" → Import GitHub repo
  3. Vercel auto-detects framework → click Deploy
  4. Every git push → automatic redeploy ✔

For plain HTML:
  vercel --prod            (from terminal, after npm i -g vercel)
  Or drag-and-drop folder at vercel.com/new
```

### Netlify : Static Sites with Forms & Functions

```
What: Similar to Vercel. Great for Hugo, Jekyll, plain HTML, React.
Free tier: 100GB bandwidth/month, 300 build minutes

Steps:
  1. Go to netlify.com → "Add new site" → Import from Git
  2. Select repo → set build command (e.g. npm run build)
  3. Deploy site

Quick deploy:
  npm install -g netlify-cli
  netlify deploy --prod --dir=./dist

Drag-and-drop: netlify.com/drop  → drop your folder → live in seconds ✔
```

### Render : Python APIs & Full-Stack

```
What: Runs Python (FastAPI, Flask), Node, Ruby, Docker containers.
Free tier: Spins down after inactivity (cold start ~30s) ⚠

Steps:
  1. Push code to GitHub
  2. render.com → "New Web Service" → Connect GitHub repo
  3. Set:
       Language: Python
       Build Command: pip install -r requirements.txt
       Start Command: uvicorn main:app --host 0.0.0.0 --port $PORT
  4. Deploy → get a .onrender.com URL

Environment variables: Add in Render dashboard → Environment tab
```

### Railway : Databases + Full Stack

```
What: Best for apps that need a database (PostgreSQL, MySQL, Redis).
Free tier: $5 credit/month (generous for small projects)

Steps:
  1. railway.app → "New Project" → Deploy from GitHub
  2. Railway auto-detects Python/Node → deploys
  3. Add a database: "+ New" → Database → PostgreSQL → auto-connected

DATABASE_URL is auto-injected into your app's environment ✔
```

### Render vs Railway vs Vercel vs Netlify

| Platform | Best for | Databases | Free tier |
| :--- | :--- | :--- | :--- |
| **Vercel** | Frontend, Next.js, React | No | Generous ✔ |
| **Netlify** | Static sites, JAMstack | No | Generous ✔ |
| **Render** | Python APIs, Docker | PostgreSQL addon | Sleeps on idle |
| **Railway** | Full-stack + database | PostgreSQL, Redis, MySQL | $5/mo credit |

---

## 6. Essential Online Tools

### Notebooks & Computing

| Tool | URL | Use |
| :--- | :--- | :--- |
| **Google Colab** | colab.research.google.com | Free Jupyter notebooks in browser, free GPU (T4) ✔ |
| **Kaggle Notebooks** | kaggle.com/code | Free notebooks + GPU, access to 150k+ datasets ✔ |
| **JupyterLite** | jupyter.org/try | Jupyter in browser, no install, no server |
| **Replit** | replit.com | Code + run + deploy in browser (Python, Node, etc.) |
| **CodeSandbox** | codesandbox.io | Frontend dev environment in browser |

### Data & APIs

| Tool | URL | Use |
| :--- | :--- | :--- |
| **Postman** | postman.com | Test REST APIs with a GUI ✔ |
| **Hoppscotch** | hoppscotch.io | Postman alternative, open-source, browser-based |
| **JSONLint** | jsonlint.com | Validate & format JSON |
| **JSON Formatter** | jsonformatter.curiousconcept.com | Prettify / minify JSON |
| **CSV Lint** | csvlint.io | Validate CSV structure |
| **Mockaroo** | mockaroo.com | Generate fake test data (CSV/JSON) |
| **Public APIs** | publicapis.dev | Directory of free public APIs to practice with |

### Dev Utilities

| Tool | URL | Use |
| :--- | :--- | :--- |
| **regex101** | regex101.com | Test & explain regular expressions ✔ |
| **crontab.guru** | crontab.guru | Write cron schedule expressions (human-readable) |
| **explainshell** | explainshell.com | Paste any shell command → see each part explained |
| **tldr.sh** | tldr.sh | Simplified man pages with examples |
| **carbon.now.sh** | carbon.now.sh | Beautiful code screenshots for sharing |
| **excalidraw** | excalidraw.com | Hand-drawn-style diagrams & architecture sketches |
| **dbdiagram.io** | dbdiagram.io | Draw database schema visually |
| **transform.tools** | transform.tools | Convert JSON↔TypeScript, CSV↔JSON, YAML↔JSON |

### AI Tools for Developers

| Tool | Use |
| :--- | :--- |
| **Claude** (claude.ai) | Code generation, explanation, debugging, writing |
| **ChatGPT** (chatgpt.com) | Same category; good for broad questions |
| **GitHub Copilot** | Autocomplete in VS Code / JetBrains |
| **Phind** | Search engine tuned for developer questions |
| **Perplexity** | AI search with citations (good for library docs) |

---

## 7. Python Environment Setup (Beginner)

Before writing any Python, you need the right environment.

### Install Python

```bash
# Check if installed
python --version    # or python3 --version

# Mac: install via Homebrew (recommended)
brew install python

# Windows: download installer from python.org
# Or install via Microsoft Store (easier)
```

### Virtual Environments : Why You Need Them

```bash
# Without venv: all packages go into global Python → version conflicts ✘
# With venv: each project gets its own isolated packages ✔

# Create a virtual environment
python -m venv .venv       # creates .venv/ folder in project

# Activate it
source .venv/bin/activate  # Mac/Linux
.venv\Scripts\activate     # Windows

# Prompt changes to show (.venv) is active:
# (.venv) user@machine:~/project$

# Install packages into the venv
pip install pandas fastapi numpy

# Save your dependencies to a file
pip freeze > requirements.txt

# Recreate the environment elsewhere
pip install -r requirements.txt

# Deactivate when done
deactivate
```

### uv : Faster Package Manager (Modern Standard)

```bash
# Install uv (replaces pip + venv)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create project + venv in one command
uv init my-project
cd my-project

# Add a package (installs + updates pyproject.toml)
uv add pandas fastapi

# Run a script with dependencies auto-managed
uv run python app.py

# Sync environment from pyproject.toml
uv sync

# uv is 10-100x faster than pip ✔
```

### VS Code : Select the Right Python

```
After creating a venv:
  1. Cmd/Ctrl + Shift + P → "Python: Select Interpreter"
  2. Choose: .venv/bin/python  (the one in your project)
  3. Bottom-left status bar shows active interpreter
  
Now VS Code uses your project's packages, not global Python.
```

---

## 8. Quick Reference Card

```
Starting a new project:
  mkdir my-project && cd my-project  # create folder
  git init                            # start version control
  python -m venv .venv               # create virtual env
  source .venv/bin/activate          # activate it
  code .                             # open in VS Code
  pip install <what-you-need>        # install packages
  pip freeze > requirements.txt      # save deps

File formats at a glance:
  .csv   → tabular data, human-readable, no types
  .json  → structured data, API responses, nested ok
  .yaml  → config files, readable, indentation matters
  .toml  → Python project config (pyproject.toml)
  .parquet → big data storage, typed, compressed, binary
  .xlsx  → Excel spreadsheet, binary, use openpyxl to read

Deploy decision:
  HTML/React/Vue site?   → Vercel or Netlify (drag & drop)
  Python API?            → Render (free) or Railway
  Needs a database?      → Railway (Postgres included)
  Need Docker?           → Render or Railway or any VPS
```

| You want to… | Tool |
| :--- | :--- |
| Write and run Python in browser | Google Colab / Kaggle |
| Edit code with AI help | Cursor or VS Code + Copilot |
| Test an API endpoint | Postman or Thunder Client |
| Debug a regex | regex101.com |
| Understand a shell command | explainshell.com |
| Validate JSON | jsonlint.com |
| Sketch an architecture | Excalidraw |
| Find a public API to practice | publicapis.dev |
| Deploy a website for free | Vercel or Netlify |
| Store & share tabular data | CSV (small) or Parquet (large) |