diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 00000000..275af65a --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,9 @@ +{ + "permissions": { + "allow": [ + "Bash(git checkout *)", + "Bash(git add *)", + "Bash(grep -n *)" + ] + } +} diff --git a/.env.local b/.env.local deleted file mode 100644 index 2711875c..00000000 --- a/.env.local +++ /dev/null @@ -1 +0,0 @@ -AUTH_SECRET=your-secret-key-change-me-in-production diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..dd61a33c --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +nul +Unused/ +backend/.env \ No newline at end of file diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 00000000..efff9eb6 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,143 @@ +# AGENTS.md — Coding Agent Guidelines for Rolemap + +This file provides build, test, and code style guidelines for agentic developers (and humans) working in the Rolemap repository. + +--- + +## What is Rolemap? + +Rolemap is an AI-powered career planning backend that: +- Seeds a global skill graph in Neo4j +- Extracts user skills from GitHub + resume +- Scrapes live job postings and maps them to graph concepts +- Generates learning paths from skill gaps + +**Current Stack:** Python-based CLI pipelines. +**Planned Stack (per `backend/README.md`):** Next.js (React + TypeScript), Tailwind CSS, Node.js, Express, PostgreSQL, Prisma. + +--- + +## Build & Test Commands + +### Environment Setup +Each module manages its own dependencies. +```bash +# Install dependencies for a specific module +cd backend/ +pip install -r requirements.txt + +# Modules: knowledge_graph, scraping, github, resume_parser, pathfinder +``` + +### Running Pipelines + +**Knowledge Graph (Neo4j seeding)** +```bash +cd backend/graph_engine/01_Seed_Base_Taxonomy +python main.py # Full pipeline +python main.py --skip-onet # Reuse cached O*NET data +python main.py --skip-roadmapsh # Reuse cached roadmap.sh data +python main.py --skip-llm # Reuse cached LLM output +``` + +**Scraping Pipeline** +```bash +cd backend/scraping +python main.py --spider linkedin --limit 5 # Scrape with LLM +python main.py --spider all --no-llm # Disable LLM extraction +python import_csv.py --csv output/file.csv --dry-run # Preview changes +``` + +**GitHub Analyzer & Resume Parser** +```bash +cd backend/github +python main.py --username + +cd ../resume_parser +python main.py --pdf +``` + +**Pathfinder (Roadmap generation)** +```bash +cd backend/graph_engine/04_Generate_Roadmaps +python generator.py "Front-End Engineer" \ + --github ../output/github_result.json \ + --resume ../output/result.json \ + --out ../output/roadmap.json +``` + +### Testing Operations +```bash +# Test file location: backend/test_extraction.py +cd backend +python test_extraction.py + +# Standalone local tuning area for LinkedIn normalization +cd backend/scraping/normalization_testing +python normalize_linkedin_csv.py --in in.csv --out out.csv --drop-noise +``` + +### Database Operations (Neo4j) +```bash +cd backend/graph_engine/05_Database_Tools +python backup_neo4j_json.py +python restore_neo4j_json.py --snapshot output/backups/.json --yes + +cd scraping +python wipe_db.py # Wipe database (CAUTION) +``` + +--- + +## Code Style Guidelines + +### Python Formatting & Types +- **Python version**: 3.9+ +- **Type hints**: Use throughout (PEP 484). +- **Line length**: Aim for ≤100 characters. +- **Docstring style**: Google-style with `"""..."""` blocks. +- **Imports**: Order as stdlib → third-party → local. + +### Naming Conventions +- **Variables/functions**: `snake_case` (e.g., `process_job`) +- **Classes**: `PascalCase` (e.g., `Neo4jWriter`) +- **Constants**: `UPPER_SNAKE_CASE` (e.g., `MAX_RETRIES`) +- **Private**: Prefix with `_` (e.g., `_helper_function`) + +### Error Handling & Logging +```python +import logging +logger = logging.getLogger(__name__) + +try: + data = fetch_from_api(url) +except requests.Timeout as e: + logger.error(f"API timeout for {url}: {e}") + return None +``` +- Catch specific exceptions. +- Use built-in `logging` module; do not use `print()` for flow control. + +### Dictionary/JSON Handling +- Use `.get()` with defaults: `user.get("email", "unknown")`. +- Validate structures: `assert isinstance(data, dict)`. +- Keys should be lowercase strings. + +--- + +## Key Developer Notes & Architecture + +1. **Idempotent Design**: Graph writes use `MERGE` for reproducibility. +2. **Metadata Tracking**: Graph entities carry `source` and `import_batch` fields for traceability. +3. **Normalize Early**: Skill synonyms and title matching happen in `scraping/matcher.py`. +4. **Skill Extraction Flow**: + - LLM-based extraction (preferred, Gemini API) -> Fallback to rule-based matching. + - For scraping quality iterations, validate in `backend/scraping/normalization_testing/` before promoting. +5. **Environment Variables**: Load with `python-dotenv`. Common vars: `NEO4J_URI`, `GEMINI_API_KEY`, `GITHUB_TOKEN`. Defined in `backend/.env`. + +--- + +## References +- **Architecture**: `backend/CLAUDE.md` for pipeline documentation. +- **MVP & Tech Stack**: `backend/README.md`. +- **Job Taxonomy**: `backend/graph_engine/01_Seed_Base_Taxonomy/config/jobs.py` diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 00000000..c921ec33 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,262 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +--- + +## What Rolemap Is + +AI-powered career planning app. Users select a target job, upload a resume and GitHub profile, and receive a skill-gap analysis, ordered learning roadmap, and daily tasks. Gamified with XP, streaks, a pixel-art character, and a cosmetics shop. + +**Current state**: Next.js 15 frontend (App Router) + FastAPI backend. Frontend reads/writes `backend/Using/data/mock_db.json` via `backend/Using/routers/user_state.py` while Neo4j pipelines are being integrated. + +--- + +## Architecture Overview + +Two data stores: +- **Neo4j** — Global knowledge graph (Jobs, Domains, Concepts, Tools, Resources + edges). Populated by the graph pipeline and job scraper. +- **PostgreSQL** — Per-user game state (schema in `backend/structure.json`); not yet wired — frontend uses `mock_db.json`. + +Backend split into two folders: + +### `backend/Using/` — API server (run this to serve the frontend) + +| Module | Path | Purpose | +|--------|------|---------| +| **API server** | `Using/main.py` | FastAPI; graph endpoints + Gemini key rotation | +| **User state router** | `Using/routers/user_state.py` | All frontend-facing endpoints; reads/writes `mock_db.json` | +| **Task generator** | `Using/Task_Gen/` | DuckDuckGo + Gemini curated resources per subtopic (V3) | +| **Quiz generator** | `Using/Quiz_Gen/quiz_generator.py` | Gemini MCQ generation | +| **Project generator** | `Using/Project_Gen/` | Project idea generation + GitHub repo evaluation | +| **GitHub analyzer** | `Using/github/` | Skill extraction from a GitHub profile (used by onboarding) | +| **Resume parser** | `Using/resume_parser/` | Skill extraction from a PDF resume (used by onboarding) | + +### `backend/Creation/` — data pipelines (seed Neo4j, scrape jobs) + +| Module | Path | Purpose | +|--------|------|---------| +| **Graph pipeline** | `Creation/graph_engine/01_Seed_Base_Taxonomy/` | Seeds Neo4j from O*NET + roadmap.sh + LLM gap-fill | +| **Roadmap generator** | `Creation/graph_engine/04_Generate_Roadmaps/` | Topological sort over Neo4j → ordered learning path | +| **Graph integrity** | `Creation/graph_engine/03_Verify_Integrity/` | Validates Neo4j graph | +| **Island removal** | `Creation/graph_engine/06_Island_Removal/` | Merges disconnected clusters | +| **DB tools** | `Creation/graph_engine/05_Database_Tools/` | Neo4j backup + restore | +| **Job scraper** | `Creation/scraping/` | Scrapes LinkedIn/Jobright/Handshake/Indeed → Neo4j | + +`POST /api/v1/onboarding/generate` orchestrates: GitHub analyzer → resume parser → `backend/Using/generator.py` (wraps `Creation/graph_engine/04_Generate_Roadmaps/`) → Gemini batch content → writes checkpoints + edges to `mock_db.json`. + +--- + +## User Flow + +1. **Sign in** (`/`) → Google or GitHub OAuth → `/OnBoarding/Major` +2. **Onboarding** (5 steps): Major → Company → Resume upload → Preferences → `/Generate` (calls `POST /api/v1/onboarding/generate`, ~5 min) → `/dashboard` +3. **Dashboard** (`/dashboard`) — XP, streak, leaderboard, roadmap cards with minimaps +4. **Map** (`/map`) — ReactFlow graph of checkpoints; pixel-art nodes; clicking lesson opens `ConceptNodePanel`; clicking quiz goes to `/quiz` +5. **Tasks** (`/tasks`) — Daily resource list (Learning + Coding cards); skill decay review cards shown above daily tasks; completing all resources for a subtopic triggers "Done for the day" screen; `POST /tasks/advance` moves to next subtopic +6. **Quiz** (`/quiz`) — Gemini MCQ; 60% pass = confetti + XP + checkpoint unlock; `POST /quiz/{checkpoint_id}/submit` +7. **Shop** (`/shop`) — Pixel-art character cosmetics purchasable with XP; `PATCH /shop/appearance` saves equipped layers + +--- + +## Gamification + +XP events (defined in `user_state.py`): +- Resource completed: +5 XP +- Subtopic completed: +10 XP +- Lesson checkpoint: +50 XP +- Project checkpoint: +200 XP +- Quiz pass: +100 XP + +Skill decay uses SM-2 spaced repetition on completed checkpoints. `GET /skills/decay` returns health (0–100) + `decay_level` (`fresh` / `review_soon` / `decaying` / `forgotten`). `POST /skills/decay/review` applies a SM-2 quality score (0–5) and advances `next_review`. + +--- + +## Frontend (`frontend/`) + +**Stack**: Next.js 15 (App Router), React 19, TypeScript, Tailwind CSS v4, NextAuth v5-beta, `@xyflow/react`, Shadcn/Radix UI. + +**Dev:** +```bash +cd frontend +npm install +npm run dev # http://localhost:3000 +npm run build +npm run lint +``` + +**Key files:** +- `lib/api.ts` — All API response types + `api.*` fetch helpers. Extend types here, never inline. +- `app/context/CharacterContext.tsx` — Global pixel-art character state (`charState`). +- `app/components/RoadmapNode.tsx` — Custom ReactFlow node (pixel-art aesthetic; follow this for any map UI). +- `app/components/ConceptNodePanel.tsx` — Slide-over panel for lesson/quiz checkpoints. +- `lib/layout.ts` — Dagre layout for ReactFlow map. + +**Character system**: Layered PNG sprites served from `public/characters/`. Equipped layers (`skin`, `eyes`, `clothes`, `pants`, `shoes`, `hair`, `accessories`) + color variant indices stored in `mock_db → users[0].character` and mirrored to `localStorage` as `character_saved` / `character_saved_variants`. Die/sleep animations in `tasks/page.tsx` use fixed-position overlays with RAF loops. + +**Auth** (`auth.ts`): NextAuth JWT with Google + GitHub. Session exposes `provider` and `githubUsername`. All pages wrapped in `providers.tsx`. + +**Frontend env** (`frontend/.env.local`): +``` +NEXT_PUBLIC_API_URL=http://localhost:8000 +AUTH_SECRET= +NEXTAUTH_URL=http://localhost:3000 +AUTH_GOOGLE_ID / AUTH_GOOGLE_SECRET +GITHUB_CLIENT_ID / GITHUB_CLIENT_SECRET +DATABASE_URL= # future use +``` + +--- + +## Backend API Server (`backend/Using/main.py`) + +```bash +cd backend/Using +pip install -r requirements_api.txt +python main.py # http://localhost:8000 | /docs for Swagger +``` + +`.env` is loaded from `backend/.env` (one level up from `Using/`). + +**User state endpoints** (`routers/user_state.py`, prefix `/api/v1`): +- `GET /users/me` — User XP/streaks +- `GET /users/me/character` — Equipped character layers +- `PATCH /users/me/character` — Save character +- `GET /dashboard` — Aggregated dashboard data + roadmap minimaps +- `GET /roadmaps/{roadmap_id}/map` — Checkpoints + edges for ReactFlow +- `GET /tasks` — Daily resource tasks for current subtopic +- `POST /tasks/advance` — Clear `daily_done` flag, move to next subtopic +- `GET /tasks/resources` — Live resource fetch (DuckDuckGo + Gemini) with cache +- `PATCH /tasks/{task_id}` — Update resource/subtopic completion; triggers XP, streak, checkpoint unlock, background pregen of next node's resources +- `GET /quiz/{checkpoint_id}` — Gemini-generated quiz questions +- `POST /quiz/{checkpoint_id}/submit` — Score quiz; pass (≥60%) unlocks downstream checkpoints +- `POST /onboarding/complete` — Mark onboarding done +- `POST /onboarding/generate` — Full GitHub → Resume → Roadmap pipeline (~5 min) +- `POST /onboarding/resume` — Upload PDF to `data/uploads/` +- `GET /skills/decay` — SM-2 decay rows for completed checkpoints +- `POST /skills/decay/review` — Apply SM-2 review (quality 0–5) +- `GET /shop` — Catalog + user unlock state + XP +- `POST /shop/purchase` — Spend XP to unlock cosmetic +- `PATCH /shop/appearance` — Save equipped layers + +**Graph/analysis endpoints** (`main.py`, prefix `/api/v1`): +- `GET /paths/prerequisites` — BFS shortest prerequisite path +- `POST /roadmap/generate` — Kahn's topological sort roadmap +- `POST /concepts/analyze` — Bidirectional BFS skill-gap analysis +- `POST /tasks/generate` — DuckDuckGo + Gemini curated tasks (V3) +- `POST /quiz/generate` — Adaptive MCQ (difficulty 1–5) +- `POST /projects/generate` — Project idea for a concept set +- `POST /projects/evaluate` — Evaluate GitHub repo against concepts +- `GET /health` + +**Gemini key rotation**: `main.py` cycles through `GEMINI_API_KEY`, `GEMINI_API_KEY_2`, … on rate-limit. Model: `gemini-2.5-flash`. + +--- + +## mock_db.json State + +`backend/Using/data/mock_db.json` is the live per-user state file. Key top-level keys: + +| Key | Purpose | +|-----|---------| +| `users[0]` | XP, streak, character, onboarding state | +| `user_gamification[0]` | Mirrors XP + streak for leaderboard | +| `roadmaps` | Roadmap records; `rm-generated` is the onboarding output | +| `roadmap_checkpoints` | Nodes with `progress`, `locked`, `kind` (`lesson`/`quiz`/`project`), `learning_goals` | +| `roadmap_edges` | Source → target edges | +| `user_subtopic_progress` | Per-subtopic completion (`subtopic__{cp_id}__{idx}`) | +| `user_resource_progress` | Per-resource completion (`resource__{cp_id}__{sub_idx}__{res_idx}`) | +| `task_resources_cache` | Cached DuckDuckGo+Gemini results per `concept`+`subtopic` | +| `quiz_questions` | Cached quiz questions per `checkpoint_id` | +| `user_shop` | Purchased item IDs + equipped layers + gender | +| `daily_done` | Boolean; set when all resources for a subtopic complete | + +Reset: `python backend/Using/data/reset_mock_db.py` + +--- + +## Key Commands + +**Backend API:** +```bash +cd backend/Using +python main.py +``` + +**Graph pipeline (seed Neo4j):** +```bash +cd backend/Creation/graph_engine/01_Seed_Base_Taxonomy +python main.py +python main.py --skip-onet --skip-roadmapsh --skip-llm # reload from cache +``` + +**Job scraper:** +```bash +cd backend/Creation/scraping +python main.py --spider linkedin --limit 5 +python main.py --spider all --no-llm +``` + +**GitHub + Resume → Roadmap (manual):** +```bash +cd backend/Using +python github/main.py --username --out output/github_result.json +python resume_parser/main.py --pdf --out output/result.json +python generator.py "Front-End Engineer" \ + --github output/github_result.json \ + --resume output/result.json \ + --out output/roadmap.json +``` + +**Neo4j backup / restore:** +```bash +cd backend/Creation +python graph_engine/05_Database_Tools/backup_neo4j_json.py +python graph_engine/05_Database_Tools/restore_neo4j_json.py --snapshot ../output/backups/.json --yes +``` + +--- + +## Environment Variables + +**Backend** (`backend/.env`): +``` +NEO4J_URI / NEO4J_USER / NEO4J_PASSWORD / NEO4J_DATABASE +GEMINI_API_KEY (+ optional GEMINI_API_KEY_2 … _9 for rotation) +ONET_API_KEY (preferred) or ONET_USERNAME + ONET_PASSWORD +OPENAI_API_KEY (LLM gap-fill for jobs without roadmap.sh slug) +GITHUB_TOKEN +``` + +--- + +## Neo4j Graph Schema + +Nodes: `Job`, `Domain`, `Concept`, `Tool`, `Resource`, `Company` +Edges: `REQUIRES`, `PREREQUISITE_FOR`, `PART_OF`, `IMPLEMENTS`, `TEACHES`, `POSTED` + +All writes are `MERGE`-based (idempotent). Scraped entities carry `source`, `import_batch`, `last_imported_at`. + +--- + +## Code Conventions + +**Backend (Python 3.9+):** +- Type hints throughout, Google-style docstrings +- `snake_case` functions/variables, `PascalCase` classes, `UPPER_SNAKE_CASE` constants +- Use `logging` (not `print`) for flow control; catch specific exceptions +- Before adding a skill normalizer, check `scraping/matcher.py` +- Snapshot Neo4j before any destructive graph operation + +**Frontend (TypeScript):** +- All API response types live in `lib/api.ts` — extend there, not inline +- New page-level components go in `app/components/`; generic/reusable ones in `components/ui/` +- Follow pixel-art node aesthetic (`RoadmapNode.tsx`) for map-related UI; teal palette `#2d5050` / `#4e8888` / `#7ab3b3` / `#d4e8e8` throughout + +--- + +## Further Reading + +- `backend/structure.json` — Neo4j + PostgreSQL schema definition +- `AGENTS.md` — additional build/test commands and code-style guide +- `backend/Using/data/shop_catalog.json` — cosmetic item definitions (categories: skin, eyes, clothes, pants, shoes, hair, accessories) diff --git a/README.md b/README.md deleted file mode 100644 index b3a6bc81..00000000 --- a/README.md +++ /dev/null @@ -1,196 +0,0 @@ -

- Job Roadmap -

- ---- - -# Rolemap 🧭 - -> Daily quests for landing your dream job. - -Rolemap is an AI-powered career planning platform that transforms vague career goals into a structured, gamified, and actionable roadmap. - -Users select 2–3 target roles (e.g., Software Engineer, Product Manager), rank dream companies, upload their resume, and connect their GitHub. Rolemap analyzes their current skill set, compares it against real hiring expectations, and generates a personalized visual roadmap with daily and weekly tasks. - -Instead of “set it and forget it” career goals, Rolemap builds systems for consistent progress. - ---- - -# ✨ Why Rolemap? - -Job preparation often feels overwhelming and unstructured. Rolemap solves this by: - -- Analyzing where you are now (Resume Parsing + GitHub) -- Comparing your skills to real job expectations -- Highlighting skill gaps -- Generating clear, executable tasks -- Reinforcing learning with checkpoints -- Gamifying consistency with streaks and points - ---- - -# 🧩 MVP Features - -## 1️⃣ Role & Company Selection -- Choose 2–3 target roles -- Select and rank dream companies -- Prioritize focus if multiple roles are selected - -## 2️⃣ Resume Upload & Parsing -- Upload PDF or DOCX resume -- Extract: - - Skills - - Experience - - Projects -- Identify missing or underdeveloped skills - -## 3️⃣ GitHub Integration -- Connect GitHub account -- Analyze repositories for: - - Languages used - - Commit activity & recency - - Project scope -- Infer actively practiced skills -- Map projects to role expectations - -## 4️⃣ Personalized Skill Gap Roadmap -- Visual roadmap with checkpoints -- Highlight missing skills -- Recommend exercises or learning resources -- Adapt roadmap as progress is made - -## 5️⃣ Daily & Weekly Tasks -- Generate small, actionable tasks -- Assign deadlines -- Sync with Google Calendar / Apple Calendar -- Notifications & reminders - -## 6️⃣ Gamification Layer -- Points system -- Streak tracking -- Leaderboard -- Milestone checkpoints - ---- - -# 🌱 Stretch Goals - -- LinkedIn parsing for improved customization -- Company culture & fit analysis -- Skill decay tracking with spaced repetition -- Anonymous forum with intern/full-time insights -- Data-driven insights on skills that mattered in hiring - ---- - -# 🗺️ Development Timeline - -| Week | Event / Date | Frontend | Backend | -|------|--------------|---------------------|--------------------| -| Week 1 | Feb 11 – Build Night 1 | Wireframes, basic layout, routing setup | Project setup, environment configuration | -| Week 2 | Feb 12–18 – Design Day + Build Night 2 | High-fidelity onboarding flow UI (role/company selection), resume/GitHub linking UI | Preliminary schema planning | -| Week 3 | Feb 19–25 – Build Night 3 | Onboarding flow fully functional, resume upload UI | Finalized schema, tables for users, roles, skills, roadmaps | -| Week 4 | Feb 26–Mar 4 – Build Night 4 | Dashboard skeleton, skill gap components | Resume parsing logic, GitHub API integration, normalize extracted skills | -| Week 5 | Mar 5–11 – Build Night 5 + Mid-Semester Review | Roadmap visualization with checkpoints | Skill gap analysis, weighted skill model, roadmap generation algorithm | -| Week 6 | Mar 17–23 – Spring Break | Daily/weekly task UI | Task generation logic, connect tasks to roadmap checkpoints | -| Week 7 | Mar 25 – Build Night 6 | Gamification UI (points, streaks, progress animations) | Progress tracking logic, scoring system backend support | -| Week 8 | Mar 26–Apr 1 – Build Night 7 + Social 2 | Leaderboard UI, calendar integration UI | Leaderboard queries, Google Calendar API integration, notifications | -| Week 9 | Apr 2–8 – Build Night 8 | Practice pitch/demo, refine UI polish | Practice demo, integration checks, bug fixes | -| Week 10 | Apr 9–15 – Build Night 9 | Practice pitch/demo | Practice demo, final integration verification | -| Final Week | Apr 16–22 – Mock Presentations & Presentation Night | Deliver final pitch/demo | Ensure deployment/stability for demo | ---- - -# 🛠️ Tech Stack - -## Frontend -- Next.js (React + TypeScript) -- Tailwind CSS -- Figma (UI/UX design) - -## Backend -- Node.js -- PostgreSQL (Supabase or self-hosted) -- Prisma (ORM) - -## AI & APIs -- OpenAI API (resume parsing, roadmap & task generation) -- GitHub REST API -- Google Calendar API - -## Tools -- GitHub -- VS Code - ---- - -# 📚 Rolemap Learning Resources - -To go from zero to building Rolemap. - ---- - -## Frontend (Next.js, React, TypeScript, Tailwind) -- [HTML & CSS Full Course](https://www.youtube.com/watch?v=mU6anWqZJcc) – Covers layout, styling, and responsive basics. -- [JavaScript Crash Course for Beginners](https://www.youtube.com/watch?v=upDLs1sn7g4) – ES6 features included; fundamentals for interactivity. -- [React JS Crash Course](https://www.youtube.com/watch?v=w7ejDZ8SWv8) – Components, state, props, and building UI. -- [TypeScript React Tutorial](https://www.youtube.com/watch?v=WBPrJSw7yQA) – Integrate TypeScript in React projects for type safety. -- [Next.js 13 Tutorial for Beginners](https://www.youtube.com/watch?v=MFuwkrseXVE) – Pages, routing, API routes, and server-side rendering. -- [Tailwind CSS Full Course 2025](https://www.youtube.com/watch?v=dFgzHOX84xQ) – Utility-first CSS framework for fast styling. -- [Figma Tutorial for Beginners](https://www.youtube.com/watch?v=FTFaQWZBqQ8) – Design mockups and high-fidelity UI. - ---- - -## Backend (Node.js, Express, PostgreSQL, Prisma) -- [Node.js Tutorial for Beginners](https://www.youtube.com/watch?v=TlB_eWDSMt4) – Setup, modules, and basic backend concepts. -- [Express.js Crash Course](https://www.youtube.com/watch?v=L72fhGm1tfE) – Routing, middleware, JSON endpoints. -- [PostgreSQL Full Course for Beginners](https://www.youtube.com/watch?v=qw--VYLpxG4) – Tables, queries, CRUD operations. -- [Prisma & PostgreSQL Beginner Tutorial](https://www.youtube.com/watch?v=F56XyD0sopA) – Simplify DB queries, migrations, and type-safe backend code. -- [REST API Crash Course](https://www.youtube.com/watch?v=Q-BpqyOT3a8) – Build API endpoints for frontend integration. -- [GitHub REST API Tutorial](https://www.youtube.com/watch?v=8uG9zLQe9Gk) – Read repos, commits, and languages programmatically. - ---- - -## AI / LLM Integration -- [OpenAI GPT-4 Tutorial](https://www.youtube.com/watch?v=2-CB1Yp3f0k) – Learn API calls in Node.js. -- [LangChain + GPT Tutorial](https://www.youtube.com/watch?v=umqFSSfT7JA) – Build pipelines for parsing and text processing. -- [Resume Parser Tutorial](https://www.youtube.com/watch?v=v3B21U2yGvQ) – Step-by-step example using GPT models. -- [Prompt Engineering Basics](https://www.youtube.com/watch?v=J3WmM6z8qA4) – Learn how to structure prompts for extraction. - ---- - -## Calendar & Notifications Integration -- [Google Calendar API Tutorial](https://www.youtube.com/watch?v=KBrqls4GJ84) – Add events/notifications programmatically. -- [Apple Calendar API Overview](https://developer.apple.com/documentation/eventkit) – iOS/macOS integration guide. - ---- - -## Gamification & UI Extras -- [How to build gamification in JS](https://www.youtube.com/watch?v=k5E2AVpwsko) – Implement points, streaks, and leaderboard logic. -- [React Charts Tutorial](https://www.youtube.com/watch?v=E3z9vA7mrUo) – Visualize roadmap completion and progress. - ---- - -## General Tools -- [VS Code Beginner Tutorial](https://www.youtube.com/watch?v=VqCgcpAypFQ) – IDE setup, extensions, and productivity tips. -- [Git & GitHub Crash Course](https://www.youtube.com/watch?v=RGOj5yH7evk) – Version control, commits, branches, pull requests. - ---- - -## ✅ Suggested Learning Path -1. HTML → CSS → JavaScript -2. React → TypeScript → Tailwind → Next.js -3. Node.js → Express → PostgreSQL → Prisma -4. REST APIs → Frontend integration -5. OpenAI API + LangChain → Resume parsing & roadmap generation -6. GitHub API → Fetch repos and activity -7. Calendar integration → Daily task reminders -8. Gamification → Points, streaks, leaderboard -9. Optional: Figma, Charts, Accessibility refinements - ---- - -# 👥 Meet the Team -- Quoc Dung Pham -- Siri Kishore Dola -- Jon Montague -- Pranay Chintakunta diff --git a/backend/.gitignore b/backend/.gitignore new file mode 100644 index 00000000..28e32856 --- /dev/null +++ b/backend/.gitignore @@ -0,0 +1,16 @@ +_archive/ +Creation/ +Using/data/uploads/ +input/ +output/ +scraping/output/ +graph_engine/01_Seed_Base_Taxonomy/data/roadmaps/ +graph_engine/01_Seed_Base_Taxonomy/data/raw/ +graph_engine/01_Seed_Base_Taxonomy/data/llm_prereqs/ +graph_engine/01_Seed_Base_Taxonomy/data/llm_concepts/ +__pycache__/ +*.pyc +.env +nul + + diff --git a/backend/Using/Project_Gen/__init__.py b/backend/Using/Project_Gen/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/backend/Using/Project_Gen/__pycache__/__init__.cpython-314.pyc b/backend/Using/Project_Gen/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 00000000..7d707ef5 Binary files /dev/null and b/backend/Using/Project_Gen/__pycache__/__init__.cpython-314.pyc differ diff --git a/backend/Using/Project_Gen/__pycache__/evaluator.cpython-314.pyc b/backend/Using/Project_Gen/__pycache__/evaluator.cpython-314.pyc new file mode 100644 index 00000000..1e6850dc Binary files /dev/null and b/backend/Using/Project_Gen/__pycache__/evaluator.cpython-314.pyc differ diff --git a/backend/Using/Project_Gen/__pycache__/generator.cpython-314.pyc b/backend/Using/Project_Gen/__pycache__/generator.cpython-314.pyc new file mode 100644 index 00000000..9d88a9e9 Binary files /dev/null and b/backend/Using/Project_Gen/__pycache__/generator.cpython-314.pyc differ diff --git a/backend/Using/Project_Gen/__pycache__/repo_fetcher.cpython-314.pyc b/backend/Using/Project_Gen/__pycache__/repo_fetcher.cpython-314.pyc new file mode 100644 index 00000000..a132ea07 Binary files /dev/null and b/backend/Using/Project_Gen/__pycache__/repo_fetcher.cpython-314.pyc differ diff --git a/backend/Using/Project_Gen/evaluator.py b/backend/Using/Project_Gen/evaluator.py new file mode 100644 index 00000000..6d29673e --- /dev/null +++ b/backend/Using/Project_Gen/evaluator.py @@ -0,0 +1,300 @@ +""" +Project evaluator. +Fetches a GitHub repo, analyzes commit signals, and uses Gemini to +produce constructive feedback across 4 dimensions. +""" + +import json +import logging +import re +from datetime import datetime, timezone +from typing import Callable, Dict, List, Optional + +from Project_Gen.repo_fetcher import build_repo_snapshot, parse_github_url + +logger = logging.getLogger(__name__) + +_GENERIC_MSG_PATTERNS = re.compile( + r"^(initial commit|init|first commit|add files?|added files?|" + r"update|updates|wip|temp|test|testing|misc|fix|fixes|" + r"commit|new commit|upload|uploaded|done|finished)\.?$", + re.IGNORECASE, +) + +_EVAL_JSON_SCHEMA = """{ + "overall_score": integer (0-100), + "code_quality": { + "score": integer (0-100), + "positives": ["string", ...], + "negatives": ["string", ...], + "feedback": "string" + }, + "ai_detection": { + "score": integer (0-100, confidence that AI wrote this), + "is_likely_ai": boolean, + "positives": ["string (evidence of human authorship)", ...], + "negatives": ["string (AI suspicion signal)", ...], + "feedback": "string" + }, + "project_structure": { + "score": integer (0-100), + "positives": ["string", ...], + "negatives": ["string", ...], + "feedback": "string" + }, + "concept_mastery": { + "score": integer (0-100), + "concepts_demonstrated": ["string", ...], + "concepts_missing": ["string", ...], + "positives": ["string", ...], + "negatives": ["string", ...], + "feedback": "string" + }, + "overall_feedback": "string (2-3 paragraphs, constructive)", + "recommendations": ["string (specific, actionable next step)", ...] +}""" + + +def compute_ai_detection_signals(commit_history: List[Dict]) -> Dict: + """ + Pure Python pre-analysis of commit signals for AI detection. + + Returns a dict with: + - total_commits + - time_span_hours (first → last) + - generic_message_count / generic_message_ratio + - max_burst (max commits within a 1-hour window) + """ + total = len(commit_history) + if total == 0: + return { + "total_commits": 0, + "time_span_hours": 0.0, + "generic_message_count": 0, + "generic_message_ratio": 0.0, + "max_burst": 0, + } + + # Count generic messages + generic = sum( + 1 for c in commit_history + if _GENERIC_MSG_PATTERNS.match(c.get("message", "").strip()) + ) + + # Parse dates for time span and burst calculation + parsed_dates = [] + for c in commit_history: + raw = c.get("date", "") + if raw: + try: + # GitHub dates are ISO 8601: "2024-03-25T14:30:00Z" + dt = datetime.fromisoformat(raw.replace("Z", "+00:00")) + parsed_dates.append(dt) + except ValueError: + pass + + parsed_dates.sort() + if len(parsed_dates) >= 2: + span = (parsed_dates[-1] - parsed_dates[0]).total_seconds() / 3600 + else: + span = 0.0 + + # Max burst: max commits within any 1-hour window + max_burst = 1 + for i, dt in enumerate(parsed_dates): + window_end = dt.timestamp() + 3600 + burst = sum(1 for other in parsed_dates if other.timestamp() <= window_end) + max_burst = max(max_burst, burst) + + return { + "total_commits": total, + "time_span_hours": round(span, 1), + "generic_message_count": generic, + "generic_message_ratio": round(generic / total, 2) if total else 0.0, + "max_burst": max_burst, + } + + +def _build_evaluate_prompt( + repo_snapshot: Dict, + concepts: List[str], + project_description: Optional[str], + ai_signals: Dict, +) -> str: + meta = repo_snapshot["metadata"] + concepts_str = ", ".join(f'"{c}"' for c in concepts) + tree_summary = repo_snapshot["file_tree_summary"] + commit_history = repo_snapshot["commit_history"] + file_contents = repo_snapshot["file_contents"] + + # File tree (capped at 100 entries) + tree_str = "\n".join(tree_summary[:100]) + if len(tree_summary) > 100: + tree_str += f"\n... and {len(tree_summary) - 100} more files" + + # Commit list + commit_lines = "\n".join( + f" {c['sha']} | {c['date'][:10] if c.get('date') else '?'} | {c['message']}" + for c in commit_history[:30] + ) + + # File contents block + files_block = "" + for path, content in file_contents.items(): + files_block += f"\n--- {path} ---\n{content}\n" + + # Original description block + desc_block = "" + if project_description: + desc_block = f"\nORIGINAL PROJECT PROMPT\n-----------------------\n{project_description}\n" + + return f"""You are a senior engineering mentor evaluating a developer's project submission on a learning platform called Rolemap. +{desc_block} +CONCEPTS TO DEMONSTRATE +------------------------ +{concepts_str} + +REPOSITORY: {meta.get('name', 'unknown')} +Description: {meta.get('description') or '(none)'} +Primary language: {meta.get('language', 'Unknown')} +Stars / Forks: {meta.get('stars', 0)} / {meta.get('forks', 0)} +Total files: {repo_snapshot['total_files']} +Topics: {', '.join(meta.get('topics', [])) or '(none)'} + +FILE STRUCTURE +-------------- +{tree_str} + +COMMIT HISTORY SIGNALS +----------------------- +Total commits: {ai_signals['total_commits']} +Time span: {ai_signals['time_span_hours']:.1f} hours (first → last commit) +Generic commit messages: {ai_signals['generic_message_count']}/{ai_signals['total_commits']} ({int(ai_signals['generic_message_ratio']*100)}%) +Largest 1-hour commit burst: {ai_signals['max_burst']} commits + +Commit log: +{commit_lines or ' (no commits found)'} + +KEY FILE CONTENTS +----------------- +{files_block or '(no file contents retrieved)'} + +EVALUATION TASK +--------------- +Score this project across 4 dimensions. Be CONSTRUCTIVE — always include both positives (what was done well) AND negatives (what needs improvement) in EVERY section, even if the project is excellent or terrible. + +SCORING CRITERIA +---------------- +code_quality (0-100): + - Code organization, naming conventions, DRY principles + - Error handling and edge cases + - Readability and consistency + - Use of appropriate patterns + +ai_detection score (0-100 = confidence that AI generated the code): + Weigh these signals: + * Very few commits OR entire project in one/two commits → high suspicion (+30) + * Generic commit messages (>50% generic ratio) → moderate suspicion (+20) + * Project uploaded all at once (time_span < 2 hours for a complex project) → high suspicion (+25) + * Overly verbose/perfect comments explaining obvious things → moderate (+15) + * No fix/debug/oops commits visible → moderate suspicion (+10) + * Code style is suspiciously consistent throughout (no learning curve) → low (+10) + * Conversely: iterative commits over days/weeks → reduce suspicion (-30) + * Varied commit messages showing real work → reduce suspicion (-20) + Set is_likely_ai: true if score > 65. + In positives: list evidence of human authorship. + In negatives: list AI suspicion signals you actually observed. + +project_structure (0-100): + - File and folder organization + - Separation of concerns + - Follows conventions for the language/framework + - README and documentation + +concept_mastery (0-100): + - Does the code ACTUALLY use the required concepts (not just import them)? + - Depth of usage — surface call vs. real understanding + - Mark concepts_demonstrated only if you saw real usage in the code + - Mark concepts_missing for concepts not clearly demonstrated + +SCORING FORMULA (apply this exactly) +-------------------------------------- +overall_score = round(code_quality * 0.30 + (100 - ai_detection.score) * 0.20 + project_structure * 0.25 + concept_mastery * 0.25) + +RULES +----- +1. overall_feedback: 2-3 paragraphs, constructive, specific to THIS repo. Reference actual files or patterns you saw. +2. recommendations: 3-5 specific, actionable next steps. Reference actual files/patterns you observed. +3. Every section MUST have at least 1 positive and 1 negative. +4. Do NOT invent file contents — only evaluate what was shown above. + +OUTPUT FORMAT +------------- +Return ONLY valid JSON — no markdown fences, no extra text. +Schema: +{_EVAL_JSON_SCHEMA}""" + + +def _parse_response(text: str) -> Dict: + """Strip markdown fences and parse JSON.""" + text = text.strip() + if text.startswith("```"): + lines = text.splitlines() + text = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:]) + return json.loads(text) + + +def _recompute_overall_score(result: Dict) -> int: + """Recompute overall_score server-side to ensure determinism.""" + cq = result.get("code_quality", {}).get("score", 0) + ai = result.get("ai_detection", {}).get("score", 0) + ps = result.get("project_structure", {}).get("score", 0) + cm = result.get("concept_mastery", {}).get("score", 0) + return round(cq * 0.30 + (100 - ai) * 0.20 + ps * 0.25 + cm * 0.25) + + +def evaluate_repository( + owner: str, + repo: str, + concepts: List[str], + project_description: Optional[str], + github_token: Optional[str], + call_gemini_fn: Callable[[str], str], +) -> Dict: + """ + Full evaluation pipeline: + 1. Fetch repo snapshot (file tree, contents, commits) + 2. Compute AI detection signals + 3. Build evaluation prompt + 4. Call Gemini + 5. Parse, recompute overall_score, and return result dict + + Raises: + RuntimeError: If Gemini call fails. + json.JSONDecodeError: If LLM returns invalid JSON. + """ + logger.info(f"Evaluating repository {owner}/{repo} for concepts: {concepts}") + + snapshot = build_repo_snapshot(owner, repo, github_token) + ai_signals = compute_ai_detection_signals(snapshot["commit_history"]) + + logger.info( + f"AI signals: {ai_signals['total_commits']} commits, " + f"{ai_signals['time_span_hours']}h span, " + f"{int(ai_signals['generic_message_ratio']*100)}% generic msgs" + ) + + prompt = _build_evaluate_prompt(snapshot, concepts, project_description, ai_signals) + raw_text = call_gemini_fn(prompt) + + result = _parse_response(raw_text) + + # Override overall_score with server-computed value + result["overall_score"] = _recompute_overall_score(result) + + # Ensure is_likely_ai is set correctly + ai_score = result.get("ai_detection", {}).get("score", 0) + if "ai_detection" in result: + result["ai_detection"]["is_likely_ai"] = ai_score > 65 + + return result diff --git a/backend/Using/Project_Gen/generator.py b/backend/Using/Project_Gen/generator.py new file mode 100644 index 00000000..8f9f954b --- /dev/null +++ b/backend/Using/Project_Gen/generator.py @@ -0,0 +1,166 @@ +""" +Project idea generator. +Uses Gemini to produce a tailored project prompt based on concepts, difficulty, and user info. +""" + +import json +import logging +from typing import Any, Callable, Dict, List, Optional + +logger = logging.getLogger(__name__) + +DIFFICULTY_CONFIG = { + 1: { + "label": "Beginner", + "complexity": "a simple single-file or two-file project", + "hours_min": 4, + "hours_max": 8, + }, + 2: { + "label": "Elementary", + "complexity": "a small multi-file project with a clear structure", + "hours_min": 8, + "hours_max": 16, + }, + 3: { + "label": "Intermediate", + "complexity": "a moderate full-feature project with multiple components", + "hours_min": 16, + "hours_max": 30, + }, + 4: { + "label": "Advanced", + "complexity": "a complex multi-component project addressing real-world concerns", + "hours_min": 30, + "hours_max": 60, + }, + 5: { + "label": "Expert", + "complexity": "a production-grade or system-design-level project", + "hours_min": 60, + "hours_max": 120, + }, +} + +_JSON_SCHEMA = """{ + "project_title": "string", + "project_description": "string (2-3 sentences describing what to build and why)", + "requirements": ["string (specific, testable requirement)", ...], + "tech_stack": ["string (concrete tool/framework name e.g. React 18, FastAPI, PostgreSQL)", ...], + "success_criteria": ["string (observable from outside the code)", ...], + "bonus_challenges": ["string (genuinely harder stretch goals)", ...], + "estimated_hours": integer, + "concepts_tested": ["string", ...] +}""" + + +def _build_generate_prompt( + concepts: List[str], + difficulty: int, + user_info: Optional[Dict[str, Any]], +) -> str: + cfg = DIFFICULTY_CONFIG[difficulty] + concepts_str = ", ".join(f'"{c}"' for c in concepts) + + user_context = "" + if user_info: + lines = [] + if user_info.get("level"): + lines.append(f" - Experience level: {user_info['level']}") + if user_info.get("preferred_language"): + lines.append(f" - Preferred language: {user_info['preferred_language']}") + if user_info.get("background"): + lines.append(f" - Background: {user_info['background']}") + if lines: + user_context = "\nLEARNER CONTEXT\n---------------\n" + "\n".join(lines) + "\n" + + return f"""You are a senior engineer and technical mentor designing real-world projects for a developer learning platform called Rolemap. + +GOAL +---- +Create ONE creative, self-contained project idea that GENUINELY requires the developer to use and understand the given concepts. The project should feel like something someone would actually build, not a toy example. + +CONCEPTS TO TEST +---------------- +{concepts_str} + +DIFFICULTY +---------- +{difficulty}/5 — {cfg["label"]}: {cfg["complexity"]} +Estimated build time: {cfg["hours_min"]}–{cfg["hours_max"]} hours +{user_context} +RULES +----- +1. The project MUST require ALL listed concepts to complete — none should be optional. +2. requirements must be specific and testable (e.g. "implement useEffect to fetch user data on mount", NOT "use React hooks"). +3. success_criteria must be observable from the outside (e.g. "the app shows a loading spinner while data is fetching"). +4. bonus_challenges must be genuinely harder stretch goals, not just "add more features". +5. tech_stack must be concrete tool names (e.g. "React 18", "FastAPI", "PostgreSQL"), not categories. +6. estimated_hours must be an integer between {cfg["hours_min"]} and {cfg["hours_max"]}. +7. concepts_tested may include implied prerequisites but MUST include all input concepts. +8. Write in second person ("Build a...", "Implement..."). + +OUTPUT FORMAT +------------- +Return ONLY valid JSON — no markdown fences, no extra text. +Schema: +{_JSON_SCHEMA}""" + + +def _parse_response(text: str) -> Dict: + """Strip markdown fences and parse JSON from Gemini response.""" + text = text.strip() + if text.startswith("```"): + lines = text.splitlines() + text = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:]) + return json.loads(text) + + +def generate_project_idea( + concepts: List[str], + difficulty: int, + user_info: Optional[Dict[str, Any]], + call_gemini_fn: Callable[[str], str], +) -> Dict: + """ + Generate a tailored project prompt using Gemini. + + Args: + concepts: List of concepts the project must test. + difficulty: 1-5 difficulty level. + user_info: Optional dict with level, preferred_language, background. + call_gemini_fn: Injected callable from main.py (uses key rotation). + + Returns: + Dict matching ProjectGenerateResponse fields. + + Raises: + RuntimeError: If Gemini call fails. + json.JSONDecodeError: If response is not valid JSON. + KeyError: If response is missing required fields. + """ + prompt = _build_generate_prompt(concepts, difficulty, user_info) + + logger.info(f"Generating project idea: concepts={concepts}, difficulty={difficulty}") + raw_text = call_gemini_fn(prompt) + + result = _parse_response(raw_text) + + # Validate required fields are present + required = { + "project_title", "project_description", "requirements", + "tech_stack", "success_criteria", "bonus_challenges", + "estimated_hours", "concepts_tested", + } + missing = required - result.keys() + if missing: + raise KeyError(f"LLM response missing fields: {missing}") + + # Clamp estimated_hours to configured range + cfg = DIFFICULTY_CONFIG[difficulty] + result["estimated_hours"] = max( + cfg["hours_min"], + min(cfg["hours_max"], int(result["estimated_hours"])), + ) + + return result diff --git a/backend/Using/Project_Gen/repo_fetcher.py b/backend/Using/Project_Gen/repo_fetcher.py new file mode 100644 index 00000000..b8bad195 --- /dev/null +++ b/backend/Using/Project_Gen/repo_fetcher.py @@ -0,0 +1,278 @@ +""" +GitHub repository fetcher for project evaluation. +Fetches file tree, selected file contents, and commit history. +""" + +import base64 +import logging +import os +import re +import time +from typing import Dict, List, Optional, Tuple + +logger = logging.getLogger(__name__) + +GITHUB_API_BASE = "https://api.github.com" + +# File extensions worth reading for code analysis +CODE_EXTENSIONS = { + ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs", + ".cpp", ".c", ".cs", ".rb", ".php", ".swift", ".kt", ".vue", + ".html", ".css", ".scss", ".sql", ".sh", ".yaml", ".yml", +} + +# Config/entry files always read regardless of extension +ALWAYS_READ_NAMES = { + "readme.md", "package.json", "requirements.txt", "pyproject.toml", + "dockerfile", "docker-compose.yml", "docker-compose.yaml", + "go.mod", "cargo.toml", "pom.xml", "build.gradle", + ".env.example", "setup.py", "setup.cfg", +} + +# Common entry-point filenames +ENTRY_POINT_NAMES = { + "main.py", "app.py", "server.py", "index.py", + "index.js", "index.ts", "app.js", "app.ts", "server.js", "server.ts", + "main.go", "main.rs", "main.java", "main.cpp", "main.c", + "app.tsx", "index.tsx", "App.tsx", "App.jsx", +} + +# Directories to skip +SKIP_DIRS = { + "node_modules", "vendor", "dist", "build", ".git", + "__pycache__", ".next", ".nuxt", "venv", ".venv", "env", + "coverage", ".nyc_output", "target", "out", "bin", "obj", +} + +MAX_FILES_TO_READ = 25 +MAX_FILE_CHARS = 8_000 +MAX_TOTAL_CHARS = 80_000 + + +def parse_github_url(raw_url: str) -> Tuple[str, str]: + """ + Parse owner and repo from any of these forms: + - https://github.com/owner/repo + - https://github.com/owner/repo.git + - github.com/owner/repo + - owner/repo + + Returns (owner, repo). Raises ValueError if unparseable. + """ + raw = raw_url.strip() + + # Try URL pattern first + match = re.search(r'(?:https?://)?(?:www\.)?github\.com/([^/\s]+)/([^/\s?.#]+)', raw) + if match: + owner = match.group(1) + repo = match.group(2).removesuffix(".git") + return owner, repo + + # Try shorthand "owner/repo" + parts = [p for p in raw.split("/") if p] + if len(parts) == 2 and all(parts): + return parts[0], parts[1].removesuffix(".git") + + raise ValueError( + f"Cannot parse GitHub URL: '{raw_url}'. " + "Expected 'https://github.com/owner/repo' or 'owner/repo'." + ) + + +def _github_get(path: str, token: Optional[str], params: Optional[Dict] = None) -> Dict: + """Make a GitHub API GET request. Retries once on rate-limit (403/429).""" + import requests + + headers = { + "Accept": "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + } + if token: + headers["Authorization"] = f"Bearer {token}" + + url = f"{GITHUB_API_BASE}{path}" + for attempt in range(2): + resp = requests.get(url, headers=headers, params=params, timeout=30) + if resp.status_code in (403, 429) and attempt == 0: + logger.warning(f"GitHub rate-limit on {path}, sleeping 60s") + time.sleep(60) + continue + resp.raise_for_status() + return resp.json() + + raise RuntimeError(f"GitHub API failed after retry: {path}") + + +def fetch_repo_metadata(owner: str, repo: str, token: Optional[str]) -> Dict: + """Fetch basic repo metadata.""" + data = _github_get(f"/repos/{owner}/{repo}", token) + return { + "name": data.get("name"), + "description": data.get("description") or "", + "language": data.get("language") or "Unknown", + "stars": data.get("stargazers_count", 0), + "forks": data.get("forks_count", 0), + "open_issues": data.get("open_issues_count", 0), + "default_branch": data.get("default_branch", "main"), + "created_at": data.get("created_at", ""), + "updated_at": data.get("updated_at", ""), + "size_kb": data.get("size", 0), + "topics": data.get("topics", []), + } + + +def fetch_file_tree(owner: str, repo: str, token: Optional[str], branch: str = "HEAD") -> List[Dict]: + """ + Fetch recursive file tree. Returns list of {path, type, size} dicts. + Only includes blob (file) entries, not trees (dirs). + """ + try: + data = _github_get( + f"/repos/{owner}/{repo}/git/trees/{branch}", + token, + params={"recursive": "1"}, + ) + except Exception as e: + logger.warning(f"File tree fetch failed: {e}") + return [] + + entries = [] + for item in data.get("tree", []): + if item.get("type") != "blob": + continue + path = item.get("path", "") + # Skip files in ignored directories + top_dir = path.split("/")[0] if "/" in path else "" + if top_dir in SKIP_DIRS: + continue + entries.append({ + "path": path, + "size": item.get("size", 0), + }) + return entries + + +def select_files_to_read(tree: List[Dict]) -> List[str]: + """ + Intelligently select which files to read. + Priority: always-read config files > entry points > largest code files. + Returns ordered list of file paths (max MAX_FILES_TO_READ). + """ + selected: List[str] = [] + seen: set = set() + + def add(path: str) -> None: + if path not in seen and len(selected) < MAX_FILES_TO_READ: + selected.append(path) + seen.add(path) + + # Tier 1: always-read files (by lowercase filename) + for entry in tree: + fname = entry["path"].split("/")[-1].lower() + if fname in ALWAYS_READ_NAMES: + add(entry["path"]) + + # Tier 2: entry-point files + for entry in tree: + fname = entry["path"].split("/")[-1] + if fname in ENTRY_POINT_NAMES: + add(entry["path"]) + + # Tier 3: largest code files + code_files = [ + e for e in tree + if any(e["path"].endswith(ext) for ext in CODE_EXTENSIONS) + and e["path"] not in seen + ] + code_files.sort(key=lambda e: e["size"], reverse=True) + for entry in code_files: + add(entry["path"]) + if len(selected) >= MAX_FILES_TO_READ: + break + + return selected + + +def fetch_file_content( + owner: str, repo: str, path: str, token: Optional[str] +) -> Optional[str]: + """ + Fetch and decode a single file's content. + Truncates to MAX_FILE_CHARS. Returns None on failure. + """ + try: + data = _github_get(f"/repos/{owner}/{repo}/contents/{path}", token) + if data.get("encoding") != "base64": + return None + raw = base64.b64decode(data["content"]).decode("utf-8", errors="replace") + return raw[:MAX_FILE_CHARS] + except Exception as e: + logger.debug(f"Failed to fetch {path}: {e}") + return None + + +def fetch_commit_history( + owner: str, repo: str, token: Optional[str], limit: int = 30 +) -> List[Dict]: + """ + Fetch recent commits. Returns list of {sha, message, date, author} dicts. + """ + try: + data = _github_get( + f"/repos/{owner}/{repo}/commits", + token, + params={"per_page": str(limit)}, + ) + commits = [] + for item in data if isinstance(data, list) else []: + commit = item.get("commit", {}) + committer = commit.get("committer") or commit.get("author") or {} + commits.append({ + "sha": item.get("sha", "")[:7], + "message": (commit.get("message") or "").split("\n")[0][:120], + "date": committer.get("date", ""), + "author": (commit.get("author") or {}).get("name", "Unknown"), + }) + return commits + except Exception as e: + logger.warning(f"Commit history fetch failed: {e}") + return [] + + +def build_repo_snapshot(owner: str, repo: str, token: Optional[str]) -> Dict: + """ + Orchestrate all GitHub API calls and return a structured snapshot. + Stays within MAX_TOTAL_CHARS budget for file contents. + """ + logger.info(f"Building repo snapshot for {owner}/{repo}") + + metadata = fetch_repo_metadata(owner, repo, token) + tree = fetch_file_tree(owner, repo, token, branch=metadata.get("default_branch", "HEAD")) + commit_history = fetch_commit_history(owner, repo, token) + + # Select and fetch file contents within budget + paths_to_read = select_files_to_read(tree) + file_contents: Dict[str, str] = {} + total_chars = 0 + + for path in paths_to_read: + if total_chars >= MAX_TOTAL_CHARS: + logger.debug(f"Char budget exhausted after {len(file_contents)} files") + break + content = fetch_file_content(owner, repo, path, token) + if content: + file_contents[path] = content + total_chars += len(content) + + logger.info( + f"Snapshot ready: {len(tree)} total files, " + f"{len(file_contents)} read, {total_chars} chars" + ) + + return { + "metadata": metadata, + "file_tree_summary": [e["path"] for e in tree], + "file_contents": file_contents, + "commit_history": commit_history, + "total_files": len(tree), + } diff --git a/backend/Using/Quiz_Gen/__pycache__/quiz_generator.cpython-314.pyc b/backend/Using/Quiz_Gen/__pycache__/quiz_generator.cpython-314.pyc new file mode 100644 index 00000000..ac8de0aa Binary files /dev/null and b/backend/Using/Quiz_Gen/__pycache__/quiz_generator.cpython-314.pyc differ diff --git a/backend/Using/Quiz_Gen/quiz_generator.py b/backend/Using/Quiz_Gen/quiz_generator.py new file mode 100644 index 00000000..51237dfc --- /dev/null +++ b/backend/Using/Quiz_Gen/quiz_generator.py @@ -0,0 +1,295 @@ +""" +QUIZ GENERATOR +============== + +Generates adaptive quiz questions for Rolemap learners. + +Inputs: + - topics : list of concept/node names being tested + - learned_resources: URLs or resource titles the user has already studied + - difficulty : 1 (Beginner) → 5 (Expert) + - learning_style : e.g. "Interactive-Heavy", "Reading-Heavy", "Hands-on" + +Output: + JSON array of quiz questions, each with: + question, type, options, correct_answer, explanation, difficulty, topic +""" + +import os +import json +import time +import argparse +from typing import List, Dict, Any +from pathlib import Path +from dotenv import load_dotenv +from google import genai + +load_dotenv(Path(__file__).parent.parent / ".env") + +# --------------------------------------------------------------------------- +# Gemini key rotation — loads all GEMINI_API_KEY, _2, _3, _4, ... from .env +# --------------------------------------------------------------------------- + +def _load_gemini_keys() -> list: + keys = [] + k = os.getenv("GEMINI_API_KEY") + if k: + keys.append(k) + i = 2 + while True: + k = os.getenv(f"GEMINI_API_KEY_{i}") + if not k: + break + keys.append(k) + i += 1 + return keys + +GEMINI_API_KEYS = _load_gemini_keys() +CURRENT_KEY_INDEX = 0 + + +def call_gemini(prompt: str) -> str: + """Call Gemini, cycling through all available keys on failure.""" + global CURRENT_KEY_INDEX + + if not GEMINI_API_KEYS: + raise RuntimeError("No Gemini API keys configured in .env") + + last_error = None + for _ in range(len(GEMINI_API_KEYS)): + key = GEMINI_API_KEYS[CURRENT_KEY_INDEX] + try: + client = genai.Client(api_key=key) + response = client.models.generate_content(model="gemini-2.5-flash", contents=prompt) + print(f" [GEMINI] Key {CURRENT_KEY_INDEX + 1}/{len(GEMINI_API_KEYS)} used") + return response.text + except Exception as e: + last_error = e + print(f" [WARNING] Gemini key {CURRENT_KEY_INDEX + 1}/{len(GEMINI_API_KEYS)} failed: {str(e)[:80]}") + CURRENT_KEY_INDEX = (CURRENT_KEY_INDEX + 1) % len(GEMINI_API_KEYS) + + raise RuntimeError(f"All {len(GEMINI_API_KEYS)} Gemini keys failed. Last: {last_error}") + + +# --------------------------------------------------------------------------- +# Difficulty mapping +# --------------------------------------------------------------------------- + +DIFFICULTY_CONFIG = { + 1: { + "label": "Beginner", + "allowed_types": ["true_false", "multiple_choice"], + "question_count": 5, + "description": "Basic definitions and recall. Use simple language and obvious distractors.", + }, + 2: { + "label": "Elementary", + "allowed_types": ["multiple_choice"], + "question_count": 6, + "description": "Conceptual understanding. Use plausible but clearly wrong distractors.", + }, + 3: { + "label": "Intermediate", + "allowed_types": ["multiple_choice", "short_answer"], + "question_count": 7, + "description": "Applied reasoning. Questions require understanding, not just recall.", + }, + 4: { + "label": "Advanced", + "allowed_types": ["short_answer", "code_challenge"], + "question_count": 8, + "description": "Deep analysis and problem-solving. Include edge cases and tradeoffs.", + }, + 5: { + "label": "Expert", + "allowed_types": ["code_challenge", "multiple_choice"], + "question_count": 10, + "description": "Architecture, debugging, and design decisions. Scenario-based questions.", + }, +} + + +# --------------------------------------------------------------------------- +# Core pipeline +# --------------------------------------------------------------------------- + +def build_resource_context(learned_resources: List[str]) -> str: + """Format all learned resources into a compact string for the prompt.""" + if not learned_resources: + return "No specific resources provided." + lines = [f" - {r}" for r in learned_resources] + return "\n".join(lines) + + +def build_prompt( + topics: List[str], + resource_context: str, + difficulty: int, + learning_style: str, +) -> str: + cfg = DIFFICULTY_CONFIG[difficulty] + topics_str = ", ".join(f'"{t}"' for t in topics) + types_str = ", ".join(cfg["allowed_types"]) + n = cfg["question_count"] + + return f"""You are a technical quiz author for a developer learning platform called Rolemap. + +Generate exactly {n} quiz questions that test knowledge of {topics_str} at {cfg["label"]} level. + +LEARNER CONTEXT +--------------- +Studied resources: +{resource_context} + +Learning style: {learning_style} + +DIFFICULTY GUIDELINES +--------------------- +Level {difficulty} — {cfg["label"]}: {cfg["description"]} +Allowed question types: {types_str} + +RULES +----- +1. Distribute questions evenly across topics if multiple topics are given. +2. For multiple_choice: provide exactly 4 options as a list ["A. ...", "B. ...", "C. ...", "D. ..."]. + correct_answer must be just the letter, e.g. "B". +3. For true_false: options must be ["True", "False"]. + correct_answer must be "True" or "False". +4. For short_answer: options must be an empty list []. + correct_answer is a concise model answer (1-3 sentences). +5. For code_challenge: include a small code snippet in the question text. + options must be an empty list []. + correct_answer is the corrected/completed code or explanation. +6. In the explanation field, reference the studied resources where relevant + (e.g. "As covered in the Docker networking docs, ..."). +7. Adapt question phrasing to a {learning_style} learner. +8. Do NOT invent URLs or resource links inside questions or explanations. + +OUTPUT FORMAT +------------- +Return ONLY a valid JSON array — no markdown fences, no extra text. +Each element must follow this exact schema: + +{{ + "question": "...", + "type": "multiple_choice | true_false | short_answer | code_challenge", + "options": ["A. ...", "B. ...", "C. ...", "D. ..."], + "correct_answer": "...", + "explanation": "...", + "difficulty": {difficulty}, + "topic": "..." +}}""" + + +def parse_llm_response(response_text: str) -> List[Dict]: + """Strip markdown fences and parse the JSON array from the LLM response.""" + text = response_text.strip() + # Strip ```json ... ``` fences if present + if text.startswith("```"): + lines = text.splitlines() + text = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:]) + return json.loads(text) + + +def validate_questions(questions: List[Dict]) -> List[Dict]: + """Drop any question missing required fields.""" + required = {"question", "type", "correct_answer", "explanation", "difficulty", "topic"} + valid = [] + for q in questions: + if not isinstance(q, dict): + continue + if not required.issubset(q.keys()): + print(f" [WARN] Dropping question missing fields: {required - q.keys()}") + continue + if "options" not in q: + q["options"] = [] + valid.append(q) + return valid + + +def generate_quiz( + topics: List[str], + learned_resources: List[str], + difficulty: int, + learning_style: str, +) -> Dict[str, Any]: + """ + Main quiz generation pipeline. + + Returns a dict with keys: metadata, questions, total_questions. + """ + print(f"\n{'='*60}") + print(f"QUIZ GENERATOR") + print(f"Topics : {', '.join(topics)}") + print(f"Difficulty : {difficulty} — {DIFFICULTY_CONFIG[difficulty]['label']}") + print(f"Style : {learning_style}") + print(f"Resources : {len(learned_resources)} provided") + print(f"{'='*60}") + + start = time.time() + + resource_context = build_resource_context(learned_resources) + prompt = build_prompt(topics, resource_context, difficulty, learning_style) + + print("\n[1/3] Sending prompt to Gemini...") + raw_text = call_gemini(prompt) + + print("[2/3] Parsing response...") + try: + raw_questions = parse_llm_response(raw_text) + except json.JSONDecodeError as e: + print(f" [ERROR] JSON parse failed: {e}") + print(f" Raw response (first 300 chars): {response.text[:300]}") + raise + + print("[3/3] Validating questions...") + questions = validate_questions(raw_questions) + + elapsed = round(time.time() - start, 2) + + output = { + "metadata": { + "topics": topics, + "difficulty": difficulty, + "difficulty_label": DIFFICULTY_CONFIG[difficulty]["label"], + "learning_style": learning_style, + "resources_used": len(learned_resources), + "processing_time_seconds": elapsed, + "model": "gemini-2.5-flash", + }, + "questions": questions, + "total_questions": len(questions), + } + + print(f"\n[SUCCESS] Generated {len(questions)} questions in {elapsed}s") + print(json.dumps(output, indent=2)) + return output + + +# --------------------------------------------------------------------------- +# CLI +# --------------------------------------------------------------------------- + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Rolemap Quiz Generator") + parser.add_argument("topics", nargs="+", help="One or more topic names") + parser.add_argument( + "--resources", nargs="*", default=[], + help="URLs or resource titles the learner has already studied" + ) + parser.add_argument( + "--difficulty", type=int, default=3, choices=[1, 2, 3, 4, 5], + help="Difficulty level 1 (Beginner) to 5 (Expert)" + ) + parser.add_argument( + "--style", default="Interactive-Heavy", + help='Learning style, e.g. "Reading-Heavy", "Hands-on", "Interactive-Heavy"' + ) + args = parser.parse_args() + + generate_quiz( + topics=args.topics, + learned_resources=args.resources, + difficulty=args.difficulty, + learning_style=args.style, + ) diff --git a/backend/Using/Task_Gen/01_generate_subtopics.py b/backend/Using/Task_Gen/01_generate_subtopics.py new file mode 100644 index 00000000..525d4d6a --- /dev/null +++ b/backend/Using/Task_Gen/01_generate_subtopics.py @@ -0,0 +1,172 @@ +import os +import csv +import json +import time +from pathlib import Path +from dotenv import load_dotenv +from neo4j import GraphDatabase +from google import genai +from pydantic import BaseModel + +# Load environment variables +load_dotenv(Path(__file__).parent.parent / ".env") + +# Configure Neo4j +NEO4J_URI = os.getenv("NEO4J_URI", "neo4j://localhost:7687") +NEO4J_USER = os.getenv("NEO4J_USER", "neo4j") +NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD", "password") + +# Configure Multiple Gemini Keys for Rate Limit Cycling +api_keys = [] +for i in range(1, 10): + key_name = "GEMINI_API_KEY" if i == 1 else f"GEMINI_API_KEY_{i}" + key = os.getenv(key_name) + if key: + api_keys.append(key) + +if not api_keys: + raise ValueError("No GEMINI_API_KEY found in .env") + +print(f"Loaded {len(api_keys)} Gemini API keys for rate limit cycling.") +clients = [genai.Client(api_key=key) for key in api_keys] +current_client_idx = 0 +MODEL_NAME = 'gemini-2.5-flash' + +PROMPT_TEMPLATE = """ +You are an expert technical curriculum designer. +I am going to provide you with a list of technology concepts from a knowledge graph. +For each concept, I need you to generate a comprehensive list of "Subtopics" that a student would need to learn to master that concept. + +Rules for Subtopic Generation: +1. Generate between 5 to 10 subtopics per concept. +2. The subtopics should be ordered logically from beginner to advanced. +3. Keep the subtopic names concise but descriptive (e.g., "React useEffect Cleanup Functions" rather than just "useEffect"). +4. Return the output STRICTLY as a JSON object where the keys are the concept names exactly as provided, and the values are arrays of strings (the subtopics). + +Example Output Format: +{ + "React": [ + "JSX Syntax and Rules", + "Functional Components and Props", + "State Management with useState", + "Handling Side Effects with useEffect", + "React Context API", + "Custom Hooks" + ] +} + +Here are the concepts to process: +""" + +def get_all_concepts(): + driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD)) + with driver.session() as session: + result = session.run("MATCH (c:Concept) RETURN c.name as name") + concepts = [record["name"] for record in result] + driver.close() + return concepts + +def process_batch(concepts_batch): + global current_client_idx + prompt = PROMPT_TEMPLATE + "\n" + json.dumps(concepts_batch) + + while True: # Keep trying until successful or hard error + client = clients[current_client_idx] + try: + response = client.models.generate_content( + model=MODEL_NAME, + contents=prompt, + config=genai.types.GenerateContentConfig( + temperature=0.2, + response_mime_type="application/json", + ) + ) + return json.loads(response.text) + except Exception as e: + err_msg = str(e) + + # Case 1: Rate Limit or Quota Exhausted + if "429" in err_msg or "RESOURCE_EXHAUSTED" in err_msg or "Quota" in err_msg: + print(f" Rate limit hit on Key {current_client_idx + 1}. Rotating to next key...") + current_client_idx = (current_client_idx + 1) % len(clients) + if current_client_idx == 0: + print(" All keys exhausted. Cooling down for 60 seconds...") + time.sleep(60) + else: + time.sleep(2) + + # Case 2: Server Overloaded (Google API hiccup) + elif "503" in err_msg or "UNAVAILABLE" in err_msg or "500" in err_msg: + print(f" Google API overloaded (503/500). Waiting 30 seconds before retrying...") + time.sleep(30) + + # Case 3: Other Errors (Parsing, etc.) + else: + print(f" Error processing batch: {e}") + try: + if 'response' in locals() and response.text: + text = response.text.replace("```json", "").replace("```", "").strip() + return json.loads(text) + except: + pass + + print(" Unrecoverable error. Skipping this batch.") + return {} + +def main(): + print("Fetching concepts from Neo4j...") + all_concepts = get_all_concepts() + + BATCH_SIZE = 20 + output_file = Path(__file__).parent / "data" / "subtopics.csv" + + processed_concepts = set() + + # Setup CSV and check for resume capability + if output_file.exists(): + with open(output_file, 'r', encoding='utf-8') as f: + reader = csv.reader(f) + header = next(reader, None) + if header and header[0] == 'concept': + for row in reader: + if row: + processed_concepts.add(row[0]) + print(f"Resuming progress: Found {len(processed_concepts)} concepts already processed.") + else: + # Create the CSV if it doesn't exist + with open(output_file, 'w', newline='', encoding='utf-8') as f: + writer = csv.writer(f) + writer.writerow(['concept', 'subtopics']) + + concepts_to_process = [c for c in all_concepts if c not in processed_concepts] + print(f"Found {len(concepts_to_process)} remaining concepts out of {len(all_concepts)} total.") + + if not concepts_to_process: + print("All concepts processed! Done.") + return + + print(f"Starting generation in batches of {BATCH_SIZE}...") + + for i in range(0, len(concepts_to_process), BATCH_SIZE): + batch = concepts_to_process[i:i+BATCH_SIZE] + batch_num = i // BATCH_SIZE + 1 + total_batches = (len(concepts_to_process) + BATCH_SIZE - 1) // BATCH_SIZE + print(f"Processing batch {batch_num}/{total_batches} ({len(batch)} concepts)...") + + results = process_batch(batch) + + # Append to CSV immediately + if results: + with open(output_file, 'a', newline='', encoding='utf-8') as f: + writer = csv.writer(f) + for concept, subtopics in results.items(): + subtopics_str = "|".join(subtopics) + writer.writerow([concept, subtopics_str]) + + # Base rate limiting pause + time.sleep(5) + + print(f"Done! Subtopics saved to {output_file}") + +if __name__ == "__main__": + main() diff --git a/backend/Using/Task_Gen/02_import_subtopics.py b/backend/Using/Task_Gen/02_import_subtopics.py new file mode 100644 index 00000000..2e1c5bb6 --- /dev/null +++ b/backend/Using/Task_Gen/02_import_subtopics.py @@ -0,0 +1,50 @@ +import os +import csv +from pathlib import Path +from dotenv import load_dotenv +from neo4j import GraphDatabase + +load_dotenv(Path(__file__).parent.parent / ".env") + +NEO4J_URI = os.getenv("NEO4J_URI", "neo4j://localhost:7687") +NEO4J_USER = os.getenv("NEO4J_USER", "neo4j") +NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD", "password") + +def import_subtopics(): + csv_file = Path(__file__).parent / "data" / "subtopics.csv" + + if not csv_file.exists(): + print(f"Error: {csv_file} does not exist. Run 01_generate_subtopics.py first.") + return + + print(f"Connecting to Neo4j at {NEO4J_URI}...") + driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD)) + + update_count = 0 + with driver.session() as session: + with open(csv_file, 'r', encoding='utf-8') as f: + reader = csv.DictReader(f) + for row in reader: + concept_name = row['concept'] + # Subtopics were saved separated by | + subtopics_list = [s.strip() for s in row['subtopics'].split('|') if s.strip()] + + if not subtopics_list: + continue + + # Update the node in Neo4j + query = """ + MATCH (c:Concept {name: $name}) + SET c.subtopics = $subtopics + RETURN count(c) as updated + """ + + result = session.run(query, name=concept_name, subtopics=subtopics_list) + if result.single()['updated'] > 0: + update_count += 1 + + driver.close() + print(f"Successfully updated {update_count} concepts with subtopics in Neo4j.") + +if __name__ == "__main__": + import_subtopics() diff --git a/backend/Using/Task_Gen/03_task_generator_v3_intelligent.py b/backend/Using/Task_Gen/03_task_generator_v3_intelligent.py new file mode 100644 index 00000000..6d41127a --- /dev/null +++ b/backend/Using/Task_Gen/03_task_generator_v3_intelligent.py @@ -0,0 +1,562 @@ +""" +V3: INTELLIGENT HYBRID TASK GENERATOR +==================================== + +Combines the best of V1 and V2: +- V2's robust dual search (Wild West + Walled Garden) +- V2's anti-hallucination filtering +- V1's intelligent LLM judging for quality ranking +- API key rotation for reliability +""" + +import os +import csv +import json +import asyncio +import time +from typing import List, Dict, Any +from pathlib import Path +from urllib.parse import urlparse +from dotenv import load_dotenv +from ddgs import DDGS +from google import genai + +# Load environment variables +load_dotenv(Path(__file__).parent.parent / ".env") + +# Load all GEMINI_API_KEY, GEMINI_API_KEY_2, GEMINI_API_KEY_3, ... dynamically +def _load_gemini_keys() -> List[str]: + keys = [] + k = os.getenv("GEMINI_API_KEY") + if k: + keys.append(k) + i = 2 + while True: + k = os.getenv(f"GEMINI_API_KEY_{i}") + if not k: + break + keys.append(k) + i += 1 + return keys + +GEMINI_API_KEYS = _load_gemini_keys() +CURRENT_KEY_INDEX = 0 + + +def get_gemini_client(): + """Return a Gemini Client using the current key.""" + if not GEMINI_API_KEYS: + raise Exception("No Gemini API keys configured in .env") + key = GEMINI_API_KEYS[CURRENT_KEY_INDEX % len(GEMINI_API_KEYS)] + print(f" [GEMINI] Key {CURRENT_KEY_INDEX + 1}/{len(GEMINI_API_KEYS)} selected") + return genai.Client(api_key=key) + +# --- Helper Functions (from V2) --- + +def load_domains(filename: str) -> List[str]: + """Loads domains from CSV files in data directory.""" + csv_path = Path(__file__).parent / "data" / filename + domains = [] + try: + with open(csv_path, 'r', encoding='utf-8') as f: + reader = csv.DictReader(f) + for row in reader: + domains.append(row['domain']) + except Exception as e: + print(f"[ERROR] Loading {filename}: {e}") + return domains + +def get_best_domains_no_api(concept: str, domain_list: List[str]) -> List[str]: + """Rule-based domain selection (enhanced from V2).""" + keyword_map = { + # Web Development + 'web': ['w3schools.com', 'developer.mozilla.org', 'freecodecamp.org', 'mdn.io', 'css-tricks.com', 'smashingmagazine.com'], + 'react': ['react.dev', 'developer.mozilla.org', 'freecodecamp.org', 'kentcdodds.com', 'javascript.info', 'w3schools.com'], + 'vue': ['vuejs.org', 'developer.mozilla.org', 'freecodecamp.org', 'w3schools.com', 'javascript.info', 'css-tricks.com'], + 'angular': ['angular.io', 'developer.mozilla.org', 'freecodecamp.org', 'w3schools.com', 'javascript.info'], + 'html': ['w3schools.com', 'developer.mozilla.org', 'mdn.io', 'freecodecamp.org', 'css-tricks.com', 'smashingmagazine.com'], + 'css': ['w3schools.com', 'developer.mozilla.org', 'mdn.io', 'css-tricks.com', 'smashingmagazine.com', 'freecodecamp.org'], + 'javascript': ['developer.mozilla.org', 'javascript.info', 'freecodecamp.org', 'w3schools.com', 'kentcdodds.com', 'dev.to'], + 'typescript': ['typescriptlang.org', 'developer.mozilla.org', 'freecodecamp.org', 'javascript.info', 'dev.to'], + + # Python & Data + 'python': ['docs.python.org', 'realpython.com', 'freecodecamp.org', 'python.org', 'dev.to', 'geeksforgeeks.org'], + 'pandas': ['pandas.pydata.org', 'realpython.com', 'freecodecamp.org', 'geeksforgeeks.org', 'towardsdatascience.com', 'kaggle.com'], + 'numpy': ['numpy.org', 'realpython.com', 'freecodecamp.org', 'geeksforgeeks.org', 'towardsdatascience.com'], + 'machine learning': ['scikit-learn.org', 'tensorflow.org', 'pytorch.org', 'realpython.com', 'huggingface.co', 'towardsdatascience.com'], + 'neural network': ['tensorflow.org', 'pytorch.org', 'huggingface.co', 'fast.ai', 'towardsdatascience.com', 'realpython.com'], + 'data science': ['scikit-learn.org', 'tensorflow.org', 'realpython.com', 'towardsdatascience.com', 'kaggle.com', 'huggingface.co'], + + # DevOps & Infrastructure + 'docker': ['docs.docker.com', 'docker.com', 'kubernetes.io', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org'], + 'kubernetes': ['kubernetes.io', 'docs.docker.com', 'freecodecamp.org', 'dev.to', 'killercoda.com', 'kodekloud.com'], + 'container': ['docs.docker.com', 'kubernetes.io', 'freecodecamp.org', 'dev.to', 'kodekloud.com'], + 'devops': ['kubernetes.io', 'docs.docker.com', 'terraform.io', 'docs.ansible.com', 'freecodecamp.org', 'dev.to'], + 'terraform': ['developer.hashicorp.com', 'terraform.io', 'hashicorp.com', 'freecodecamp.org', 'dev.to', 'kodekloud.com'], + 'jenkins': ['jenkins.io', 'freecodecamp.org', 'github.com', 'dev.to', 'geeksforgeeks.org'], + 'ci/cd': ['jenkins.io', 'github.com', 'freecodecamp.org', 'dev.to', 'docs.docker.com'], + 'ansible': ['docs.ansible.com', 'ansible.com', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org'], + 'vault': ['developer.hashicorp.com', 'vaultproject.io', 'hashicorp.com', 'freecodecamp.org', 'dev.to'], + + # Cloud + 'aws': ['docs.aws.amazon.com', 'aws.amazon.com', 'freecodecamp.org', 'dev.to', 'acloudguru.com'], + 'azure': ['learn.microsoft.com', 'azure.microsoft.com', 'freecodecamp.org', 'dev.to', 'acloudguru.com'], + 'gcp': ['cloud.google.com', 'freecodecamp.org', 'dev.to', 'acloudguru.com', 'qwiklabs.com'], + 'cloud': ['docs.aws.amazon.com', 'learn.microsoft.com', 'cloud.google.com', 'freecodecamp.org', 'acloudguru.com'], + + # Security + 'security': ['owasp.org', 'portswigger.net', 'tryhackme.com', 'hackthebox.com', 'freecodecamp.org', 'cloudflare.com'], + 'owasp': ['owasp.org', 'portswigger.net', 'tryhackme.com', 'freecodecamp.org', 'geeksforgeeks.org'], + 'cryptography': ['cryptography.io', 'owasp.org', 'portswigger.net', 'freecodecamp.org', 'geeksforgeeks.org'], + 'network': ['cloudflare.com', 'cisco.com', 'freecodecamp.org', 'geeksforgeeks.org', 'developer.mozilla.org'], + + # Databases + 'database': ['postgresql.org', 'docs.mongodb.com', 'redis.io', 'freecodecamp.org', 'geeksforgeeks.org', 'dev.to'], + 'postgresql': ['postgresql.org', 'postgresqltutorial.com', 'freecodecamp.org', 'realpython.com', 'geeksforgeeks.org'], + 'mongodb': ['docs.mongodb.com', 'mongodb.com', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org'], + 'redis': ['redis.io', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org', 'realpython.com'], + 'sql': ['postgresql.org', 'w3schools.com', 'freecodecamp.org', 'sqlzoo.net', 'geeksforgeeks.org', 'postgresqltutorial.com'], + + # Backend + 'nodejs': ['nodejs.org', 'freecodecamp.org', 'developer.mozilla.org', 'dev.to', 'geeksforgeeks.org'], + 'express': ['expressjs.com', 'freecodecamp.org', 'developer.mozilla.org', 'dev.to', 'geeksforgeeks.org'], + 'fastapi': ['fastapi.tiangolo.com', 'realpython.com', 'github.com', 'dev.to', 'geeksforgeeks.org'], + 'django': ['docs.djangoproject.com', 'djangoproject.com', 'realpython.com', 'dev.to', 'geeksforgeeks.org'], + 'flask': ['flask.palletsprojects.com', 'realpython.com', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org'], + + # Architecture & Design + 'architecture': ['martinfowler.com', 'refactoring.guru', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org'], + 'design pattern': ['refactoring.guru', 'martinfowler.com', 'freecodecamp.org', 'dev.to', 'geeksforgeeks.org'], + + # Project Management + 'agile': ['atlassian.com', 'scrum.org', 'pmi.org', 'freecodecamp.org', 'dev.to'], + 'scrum': ['scrum.org', 'atlassian.com', 'pmi.org', 'freecodecamp.org', 'dev.to'], + } + + concept_lower = concept.lower() + + # Try exact keyword matches (prioritize longer matches) + for keyword in sorted(keyword_map.keys(), key=len, reverse=True): + if keyword in concept_lower: + matches = keyword_map[keyword] + available = [d for d in matches if d in domain_list] + if available: + return available[:5] + + # Fallback: return first 5 domains + return domain_list[:5] if domain_list else [] + +def perform_ddg_search(query: str, max_results: int = 10) -> List[Dict]: + """Performs DuckDuckGo search (from V2).""" + results = [] + try: + ddgs = DDGS() + for r in ddgs.text(query, max_results=max_results): + results.append({ + "title": r.get("title", ""), + "url": r.get("href", ""), + "snippet": r.get("body", "")[:200] + }) + except Exception as e: + print(f" [WARNING] DuckDuckGo search error: {str(e)[:100]}") + return results + +def basic_quality_filter(search_results: List[Dict]) -> List[Dict]: + """Basic quality filtering (from V2 enhanced) with deduplication.""" + good_results = [] + seen_urls = set() # Track seen URLs for deduplication + + for result in search_results: + url = result.get('url', '').lower() + title = result.get('title', '') + snippet = result.get('snippet', '').lower() + + # Deduplicate by URL + normalized_url = url.rstrip('/') # Normalize trailing slashes + if normalized_url in seen_urls: + continue + seen_urls.add(normalized_url) + + # Filter out low-quality sources + if any(block in url for block in ['medium.com', 'quora.com', 'pinterest.com']): + continue + if 'paywall' in snippet or 'login required' in snippet: + continue + if len(title) < 5: + continue + + # Filter out generic landing pages + generic_endings = ['/news/', '/docs/', '/blog/', '/learn/', '/tutorials/', '.com/', '.org/', '.dev/'] + if any(url.endswith(ending) for ending in generic_endings): + continue + + # Filter out tag/category pages + generic_patterns = ['/tag/', '/tags/', '/category/', '/categories/', '/topics/', '/search', '/author/', '/authors/', '/user/', '/users/', '/profile/'] + if any(pattern in url for pattern in generic_patterns): + continue + + # Ensure URL specificity + url_parts = url.split('/') + if len(url_parts) <= 4: + continue + + good_results.append(result) + + return good_results + +def filter_similar_links(results: List[Dict]) -> List[Dict]: + """ + Remove URLs that are sub-paths of other URLs on the same domain. + + Example: if both /engine/network/ and /engine/network/drivers/bridge/ + are present, keep only the more specific (longer path) one. + """ + if not results: + return [] + + parsed = [] + for r in results: + url = r.get('url', '') + try: + p = urlparse(url.lower().rstrip('/')) + parts = [x for x in p.path.split('/') if x] + parsed.append((r, p.netloc, parts)) + except Exception: + parsed.append((r, '', [])) + + keep = [True] * len(parsed) + + for i in range(len(parsed)): + if not keep[i]: + continue + ri, domain_i, parts_i = parsed[i] + for j in range(len(parsed)): + if i == j or not keep[j]: + continue + rj, domain_j, parts_j = parsed[j] + if domain_i != domain_j or not domain_i: + continue + # Check if parts_i is a strict prefix of parts_j (same section of docs) + if len(parts_i) < len(parts_j) and parts_j[:len(parts_i)] == parts_i: + # i is the parent; discard i, keep the more specific j + keep[i] = False + break + + filtered = [r for r, flag in zip(results, keep) if flag] + removed = len(results) - len(filtered) + if removed: + print(f" [SIMILARITY] Removed {removed} near-duplicate URL(s)") + return filtered + + +def prioritize_by_credible_domains(results: List[Dict], credible_domains: List[str]) -> List[Dict]: + """ + Boost results whose domain appears in the credible CSV list to the front. + If there are ≥5 credible results, return only those (skip the rest). + """ + credible, other = [], [] + for r in results: + url = r.get('url', '').lower() + if any(domain in url for domain in credible_domains): + credible.append(r) + else: + other.append(r) + + if len(credible) >= 5: + print(f" [CREDIBLE] {len(credible)} credible-domain results — skipping non-credible sources") + return credible + return credible + other + + +# --- V3 NEW: INTELLIGENT LLM JUDGE --- + +def intelligent_llm_curation(concept: str, subtopic: str, preference: str, task_type: str, search_results: List[Dict], count: int) -> List[Dict]: + """ + V3 INNOVATION: Intelligent LLM-based result curation + Evaluates results by authority, relevance, and quality - not just search source. + """ + if not search_results: + return [] + + try: + client = get_gemini_client() + + # Prepare results for LLM evaluation + results_text = "" + for i, result in enumerate(search_results): + results_text += f"\n{i+1}. Title: {result.get('title', 'No title')}\n" + results_text += f" URL: {result.get('url', '')}\n" + results_text += f" Snippet: {result.get('snippet', '')[:150]}...\n" + + prompt = f"""You are a technical learning resource curator. Evaluate these search results for learning "{subtopic}" in the context of "{concept}" for a {preference.replace('-', ' ')} learning approach. + +SEARCH RESULTS: +{results_text} + +TASK: Select the {count} BEST resources for {task_type} tasks. Prioritize: + +1. **Authority**: Official documentation > established tech sites > community blogs +2. **Relevance**: Directly covers "{subtopic}" > general "{concept}" content +3. **Quality**: Specific technical content > generic overviews +4. **Preference match**: {preference} learning style + +Return ONLY a JSON array where each element has: +- "index": the result number you selected +- "description": 1-2 sentence description of what this resource covers and why it's useful (do NOT start with "Learn") +- "objectives": array of 2-3 short bullet points describing what the learner should take away from this resource + +Example: [{{"index": 1, "description": "Official AWS guide...", "objectives": ["Understand...", "Configure..."]}}] +No markdown, no extra text, just the JSON array.""" + + response = client.models.generate_content(model="gemini-2.5-flash", contents=prompt) + + # Parse LLM response + response_text = response.text.strip() + if response_text.startswith("```"): + response_text = response_text.split("```")[1] + if response_text.startswith("json"): + response_text = response_text[4:] + response_text = response_text.strip() + if response_text.startswith('[') and response_text.endswith(']'): + selected = json.loads(response_text) + + curated_results = [] + for item in selected: + idx = item if isinstance(item, int) else item.get("index", 0) + if 1 <= idx <= len(search_results) and len(curated_results) < count: + result = search_results[idx - 1] + desc = item.get("description", "") if isinstance(item, dict) else "" + objectives = item.get("objectives", []) if isinstance(item, dict) else [] + curated_results.append({ + "title": result.get("title", "Resource")[:80], + "description": desc or f"Covers {subtopic} as part of {concept}.", + "url": result.get("url"), + "type": task_type, + "objectives": objectives[:4], + "curated_by": "LLM-intelligent (anti-hallucination)" + }) + + print(f" [SUCCESS] LLM curated {len(curated_results)} {task_type} tasks") + return curated_results + else: + raise Exception(f"Invalid LLM response format: {response_text[:100]}") + + except Exception as e: + print(f" [WARNING] LLM curation failed: {str(e)[:100]}") + print(f" [FALLBACK] Using rule-based curation...") + + # Fallback to V2 rule-based curation + return fallback_rule_curation(concept, subtopic, task_type, search_results, count) + +def fallback_rule_curation(concept: str, subtopic: str, task_type: str, search_results: List[Dict], count: int) -> List[Dict]: + """Fallback rule-based curation if LLM fails.""" + # Authority-based ranking (better than V2's search-type ranking) + official_domains = [ + # Cloud & DevOps + 'docs.docker.com', 'docker.com', 'developer.hashicorp.com', 'hashicorp.com', + 'kubernetes.io', 'terraform.io', 'ansible.com', 'docs.ansible.com', + 'aws.amazon.com', 'docs.aws.amazon.com', 'cloud.google.com', 'learn.microsoft.com', + + # Web Development + 'react.dev', 'vuejs.org', 'angular.io', 'developer.mozilla.org', 'nodejs.org', + + # Languages & Frameworks + 'docs.python.org', 'go.dev', 'rust-lang.org', 'typescriptlang.org', + 'djangoproject.com', 'flask.palletsprojects.com', 'fastapi.tiangolo.com', + + # Databases + 'postgresql.org', 'docs.mongodb.com', 'redis.io', 'mysql.com', + + # Educational + 'freecodecamp.org', 'w3schools.com' + ] + + # Rank by authority + official_results = [] + community_results = [] + + for result in search_results: + url = result.get('url', '') + if any(domain in url for domain in official_domains): + official_results.append(result) + else: + community_results.append(result) + + # Combine with authority priority + prioritized = official_results + community_results + + curated_tasks = [] + for result in prioritized[:count]: + if result.get("url"): + snippet = result.get('snippet', '')[:100] + # Generate generic but useful objectives from context + objectives = [ + f"Understand the fundamentals of {subtopic}", + f"Apply key {concept} concepts from this resource", + f"Identify how {subtopic} fits into {concept} workflows", + ] + curated_tasks.append({ + "title": result.get("title", "Resource")[:80], + "description": f"Learn {subtopic}: {snippet}", + "url": result.get("url"), + "type": task_type, + "curated_by": "rule-based authority ranking", + "objectives": objectives, + }) + + print(f" [FALLBACK] Rule-based curated {len(curated_tasks)} {task_type} tasks") + return curated_tasks + +# --- V3 MAIN PIPELINE --- + +async def gather_links_v3(concept: str, subtopic: str, task_type: str, domains_file: str, wild_west_keywords: str): + """V3: Enhanced link gathering with better domain selection. + + Returns (filtered_results, all_trusted_domains) so the caller can + run domain prioritization before LLM curation. + """ + + # 1. Enhanced Domain Selection + all_trusted_domains = load_domains(domains_file) + selected_domains = get_best_domains_no_api(concept, all_trusted_domains) + + if not selected_domains: + selected_domains = all_trusted_domains[:5] + + print(f"\n--- V3 Gathering {task_type} Links ---") + print(f" Concept-matched domains: {', '.join(selected_domains)}") + + # 2. Dual Search + domain_keywords = " OR ".join(selected_domains) + walled_garden_query = f"{concept} {subtopic} ({domain_keywords})" + wild_west_query = f'"{concept}" "{subtopic}" {wild_west_keywords}' + + walled_garden_results = perform_ddg_search(walled_garden_query, max_results=10) + wild_west_results = perform_ddg_search(wild_west_query, max_results=10) + + # 3. Mark sources and combine + for r in walled_garden_results: + r['source_type'] = 'Walled Garden' + for r in wild_west_results: + r['source_type'] = 'Wild West' + + combined = walled_garden_results + wild_west_results + + # 4. Link similarity filtering (remove near-duplicate URLs before quality filter) + deduplicated = filter_similar_links(combined) + + # 5. Basic quality filtering + filtered = basic_quality_filter(deduplicated) + + print(f" Found: {len(walled_garden_results)} walled + {len(wild_west_results)} wild" + f" → {len(deduplicated)} after similarity check → {len(filtered)} after quality filter") + + return filtered, all_trusted_domains + +async def generate_tasks_v3(job: str, concept: str, subtopic: str, preference: str): + """ + V3 MAIN PIPELINE: Intelligent Hybrid Task Generation + + Combines: + - V2's robust dual search + anti-hallucination + - V1's intelligent LLM judging (with fallback) + - Enhanced domain mapping + - API key rotation for reliability + """ + + print(f"\n{'='*60}") + print(f"V3 INTELLIGENT HYBRID TASK GENERATION") + print(f"Concept: {concept} -> {subtopic}") + print(f"Profile: {job}, Preference: {preference}") + print(f"Mode: LLM-intelligent with rule-based fallback") + print(f"{'='*60}") + + start_time = time.time() + + try: + # 1. Gather Learning Links + learning_links, learn_credible_domains = await gather_links_v3( + concept=concept, + subtopic=subtopic, + task_type="Learning", + domains_file="credible_website_learn.csv", + wild_west_keywords="tutorial OR explanation OR guide OR documentation" + ) + + # 2. Gather Coding Links + coding_links, coding_credible_domains = await gather_links_v3( + concept=concept, + subtopic=subtopic, + task_type="Coding", + domains_file="credible_website_coding.csv", + wild_west_keywords="interactive exercise OR coding practice OR GitHub template OR example" + ) + + # 3. Prioritize results from credible domain lists (before LLM curation) + print(f"\n--- V3 Domain Prioritization ---") + learning_links = prioritize_by_credible_domains(learning_links, learn_credible_domains) + coding_links = prioritize_by_credible_domains(coding_links, coding_credible_domains) + + # 4. V3 INNOVATION: Intelligent LLM Curation + print(f"\n--- V3 Intelligent LLM Curation ---") + + learning_tasks = intelligent_llm_curation(concept, subtopic, preference, "Learning", learning_links, 3) + coding_tasks = intelligent_llm_curation(concept, subtopic, preference, "Coding", coding_links, 2) + + elapsed_time = time.time() - start_time + + final_output = { + "metadata": { + "concept": concept, + "subtopic": subtopic, + "preference": preference, + "version": "V3-intelligent-hybrid", + "processing_time_seconds": round(elapsed_time, 2), + "llm_enhanced": True + }, + "learning_tasks": learning_tasks, + "coding_tasks": coding_tasks, + "total_resources_found": len(learning_links) + len(coding_links) + } + + print(f"\n[V3 SUCCESS] Generation Complete!") + print(f"Processing time: {elapsed_time:.2f}s") + print(f"Total resources found: {final_output['total_resources_found']}") + print(f"Learning tasks curated: {len(learning_tasks)}") + print(f"Coding tasks curated: {len(coding_tasks)}") + print(json.dumps(final_output, indent=2)) + + return final_output + + except Exception as e: + print(f"\n[V3 ERROR] {str(e)}") + raise + +# --- CLI Interface --- + +if __name__ == "__main__": + import sys + + if len(sys.argv) > 1: + # Dynamic input mode + job = sys.argv[1] if len(sys.argv) > 1 else "Software Engineer" + concept = sys.argv[2] if len(sys.argv) > 2 else "Python" + subtopic = sys.argv[3] if len(sys.argv) > 3 else "List Comprehensions" + preference = sys.argv[4] if len(sys.argv) > 4 else "Interactive-Heavy" + + print(f"\n[V3] Running with provided arguments:") + print(f" Job: {job}") + print(f" Concept: {concept}") + print(f" Subtopic: {subtopic}") + print(f" Preference: {preference}\n") + + asyncio.run(generate_tasks_v3(job, concept, subtopic, preference)) + else: + # Interactive mode + print("\n=== V3 INTELLIGENT HYBRID TASK GENERATOR ===\n") + job = input("Enter job profile (default: Software Engineer): ").strip() or "Software Engineer" + concept = input("Enter concept (default: Python): ").strip() or "Python" + subtopic = input("Enter subtopic (default: List Comprehensions): ").strip() or "List Comprehensions" + preference = input("Enter learning preference (default: Interactive-Heavy): ").strip() or "Interactive-Heavy" + + asyncio.run(generate_tasks_v3(job, concept, subtopic, preference)) \ No newline at end of file diff --git a/backend/Using/Task_Gen/USAGE_GUIDE.txt b/backend/Using/Task_Gen/USAGE_GUIDE.txt new file mode 100644 index 00000000..2b361c4f --- /dev/null +++ b/backend/Using/Task_Gen/USAGE_GUIDE.txt @@ -0,0 +1,90 @@ +================================================================================ +TASK GENERATOR - USAGE GUIDE +================================================================================ + +WHAT IT DOES: +The Task Generator creates curated learning resources for any concept/subtopic +using an anti-hallucination AI pipeline that never makes up URLs. + +================================================================================ +RUNNING THE SCRIPT +================================================================================ + +METHOD 1: COMMAND-LINE ARGUMENTS (Recommended for testing) +----------- +python Task_Gen/03_task_generator.py "[Job]" "[Concept]" "[Subtopic]" "[Preference]" + +EXAMPLES: + python Task_Gen/03_task_generator.py "Frontend Engineer" "React" "useEffect Cleanup Functions" "Interactive-Heavy" + python Task_Gen/03_task_generator.py "Data Scientist" "Python" "Pandas" "Theory-Heavy" + python Task_Gen/03_task_generator.py "Security Engineer" "Penetration Testing" "Reconnaissance" "Hands-on-Heavy" + +METHOD 2: INTERACTIVE MODE +----------- +python Task_Gen/03_task_generator.py +(then answer the prompts) + +================================================================================ +EXPECTED OUTPUT +================================================================================ + +For each concept, you'll get: +- 3 Learning Tasks (videos/articles/tutorials) +- 2 Coding Tasks (interactive exercises/GitHub repos) + +Each task includes: + * title: Name of the resource + * description: Why this resource is useful for this specific topic + * url: The actual URL (never hallucinated) + * type: "Learning" or "Coding" + +================================================================================ +IMPORTANT NOTES +================================================================================ + +1. API QUOTA LIMITATION + - First run may work, but multiple runs quickly hit Gemini API limits + - Free tier: 20 requests/minute for gemini-2.5-flash + - Production: Need paid Gemini API tier or alternative approach + +2. SEARCH QUALITY + - Quality depends on how well concepts match trusted domain databases + - Some niche concepts may return no results + - All results are from actual search engines (never hallucinated) + +3. FALLBACK BEHAVIOR + - If LLM quota exceeded: Returns actual search results directly + - If no search results: Returns empty array (never makes up URLs) + +================================================================================ +SUPPORTED CONCEPTS +================================================================================ + +The system works best with: +- Programming languages (Python, JavaScript, Java, etc.) +- Web frameworks (React, Django, FastAPI, etc.) +- DevOps tools (Docker, Kubernetes, Terraform, etc.) +- Cybersecurity topics (Penetration Testing, Cryptography, etc.) +- Data science (Pandas, Spark, Machine Learning, etc.) + +Run against any of the 1,124 concepts in your Neo4j database! + +================================================================================ +TROUBLESHOOTING +================================================================================ + +ERROR: "API quota exceeded" +SOLUTION: Wait 60 seconds and try again, or upgrade to paid Gemini tier + +ERROR: "No search results found" +CAUSE: Domain selection didn't find matching resources +TRY: Use different concept/subtopic combo or add more domains to CSV files + +ERROR: "DDGS() not found" +FIX: pip install duckduckgo-search + +ERROR: "Input/output encoding" +CAUSE: Terminal encoding issue +FIX: Should be auto-handled, but ensure UTF-8 terminal + +================================================================================ diff --git a/backend/Using/Task_Gen/data/credible_website_coding.csv b/backend/Using/Task_Gen/data/credible_website_coding.csv new file mode 100644 index 00000000..64034116 --- /dev/null +++ b/backend/Using/Task_Gen/data/credible_website_coding.csv @@ -0,0 +1,51 @@ +domain,category,description +w3schools.com,General,Interactive exercises for web technologies and languages +freecodecamp.org,General,Interactive coding curriculum and projects +leetcode.com,Algorithms,Algorithmic coding challenges +hackerrank.com,Algorithms,Algorithmic and domain-specific challenges +codewars.com,Algorithms,Community-created coding challenges +theodinproject.com,Full Stack,Project-based full stack curriculum +exercism.org,General,Language-specific coding exercises +codecademy.com,General,Interactive courses (some free exercises) +github.com,Projects,Code repositories and templates for projects +kaggle.com,Data Science,Data science competitions and notebooks +datacamp.com,Data Science,Interactive data science and ML exercises +sqlzoo.net,Database,Interactive SQL tutorials and exercises +leetcode.com/studyplan/sql,Database,SQL specific challenges on LeetCode +hackthebox.com,Security,Interactive cybersecurity labs and machines +tryhackme.com,Security,Guided cybersecurity rooms and exercises +overthewire.org,Security,Wargames for learning security concepts +picoctf.com,Security,Capture The Flag challenges +kodekloud.com,DevOps,Interactive DevOps and Cloud labs (some free) +killercoda.com,DevOps,Interactive Kubernetes and CKA/CKS simulators +katacoda.com,DevOps,Interactive browser-based environments (legacy but some still active) +labs.play-with-docker.com,DevOps,Interactive Docker playground +labs.play-with-k8s.com,DevOps,Interactive Kubernetes playground +frontendmentor.io,Frontend,Frontend coding challenges with real designs +cssbattle.dev,Frontend,CSS code-golfing challenges +flexboxfroggy.com,Frontend,Interactive game for learning CSS Flexbox +cssgridgarden.com,Frontend,Interactive game for learning CSS Grid +javascript30.com,JavaScript,30 day vanilla JS coding challenge +codingbat.com,General,Live coding problems to build coding logic +projecteuler.net,Algorithms,Mathematical and computational programming problems +spoj.com,Algorithms,Project Euler alternative +coderbyte.com,General,Live coding problems for Java and Python +edabit.com,General,Live coding problems for Java and Python +repl.it,General,Interactive browser-based coding environments and challenges +codesandbox.io,General,Interactive browser-based coding environments +stackblitz.com,General,Interactive browser-based coding environments (good for React/Vue) +jsfiddle.net,General,Interactive browser-based coding environments +glitch.com,General,Interactive browser-based coding environments +codepen.io,General,Interactive browser-based coding environments +leetcode.com/studyplan/pandas,Data Science,Pandas specific challenges on LeetCode +machinelearningmastery.com,Machine Learning,Machine learning tutorials and exercises +fast.ai,Machine Learning,Deep learning courses and exercises +coursera.org,General,Interactive courses (some free exercises) +udacity.com,General,Interactive courses (some free exercises) +pluralsight.com,General,Interactive courses (some free exercises) +educative.io,General,Interactive courses (some free exercises) +acloudguru.com,Cloud,Cloud computing labs and exercises (some free) +linuxacademy.com,Cloud,Linux and Cloud computing labs and exercises (some free) +qwiklabs.com,Cloud,Cloud computing labs and exercises (some free) +whizlabs.com,Cloud,Cloud computing labs and exercises (some free) +cloudacademy.com,Cloud,Cloud computing labs and exercises (some free) diff --git a/backend/Using/Task_Gen/data/credible_website_learn.csv b/backend/Using/Task_Gen/data/credible_website_learn.csv new file mode 100644 index 00000000..0346a8cd --- /dev/null +++ b/backend/Using/Task_Gen/data/credible_website_learn.csv @@ -0,0 +1,56 @@ +domain,category,description +youtube.com,Video,General video tutorials and explanations +developer.mozilla.org,Web,MDN Web Docs (HTML/CSS/JS) +dev.to,Articles,Community driven developer articles +medium.com,Articles,Developer articles (some paywalls but good for niche) +towardsdatascience.com,Data Science,Data Science and Machine Learning articles +kubernetes.io,DevOps,Official Kubernetes documentation +docs.docker.com,DevOps,Official Docker documentation +docs.aws.amazon.com,Cloud,Official AWS documentation +learn.microsoft.com,Cloud,Official Azure documentation +cloud.google.com/docs,Cloud,Official GCP documentation +react.dev,Frontend,Official React documentation +angular.io,Frontend,Official Angular documentation +vuejs.org,Frontend,Official Vue.js documentation +python.org,Backend,Official Python documentation +java.com,Backend,Official Java documentation +docs.oracle.com/en/java,Backend,Oracle Java documentation +golang.org,Backend,Official Go documentation +rust-lang.org,Backend,Official Rust documentation +ruby-lang.org,Backend,Official Ruby documentation +php.net,Backend,Official PHP documentation +postgresqltutorial.com,Database,PostgreSQL tutorials +mysqltutorial.org,Database,MySQL tutorials +mongodb.com/docs,Database,Official MongoDB documentation +redis.io/docs,Database,Official Redis documentation +elasticsearch.io,Database,Official Elasticsearch documentation +geeksforgeeks.org,General,General computer science and programming articles +realpython.com,Python,Python specific tutorials and articles +freecodecamp.org/news,Articles,freeCodeCamp news and articles +css-tricks.com,Frontend,CSS and Frontend specific articles +smashingmagazine.com,Frontend,Web design and development articles +kentcdodds.com,Frontend,Frontend and React specific articles +martinfowler.com,Architecture,Software architecture and design patterns +refactoring.guru,Architecture,Design patterns and refactoring +owasp.org,Security,Cybersecurity and web application security +portswigger.net,Security,Web security academy and articles +tryhackme.com,Security,Cybersecurity learning paths (some articles) +hackthebox.com,Security,Cybersecurity learning (some articles) +cisco.com,Networking,Networking documentation and articles +cloudflare.com/learning,Networking,Web performance and security learning center +nginx.com/resources,DevOps,NGINX and web server resources +hashicorp.com/resources,DevOps,Terraform and Vault resources +ansible.com/resources,DevOps,Ansible resources +pytorch.org/tutorials,Machine Learning,Official PyTorch tutorials +tensorflow.org/tutorials,Machine Learning,Official TensorFlow tutorials +huggingface.co/docs,Machine Learning,Hugging Face documentation +scikit-learn.org,Machine Learning,Official Scikit-Learn documentation +kaggle.com/learn,Machine Learning,Kaggle learning courses +atlassian.com/agile,Project Management,Agile and Scrum methodologies +scrum.org,Project Management,Official Scrum resources +pmi.org,Project Management,Project Management Institute resources +developer.hashicorp.com,DevOps,Official HashiCorp developer docs (Terraform/Vault) +terraform.io,DevOps,Official Terraform documentation +docs.ansible.com,DevOps,Official Ansible documentation +vaultproject.io,Security,Official Vault documentation +docs.python.org,Python,Official Python documentation diff --git a/backend/Using/Task_Gen/data/final_missing_subtopics.csv b/backend/Using/Task_Gen/data/final_missing_subtopics.csv new file mode 100644 index 00000000..850e6fdc --- /dev/null +++ b/backend/Using/Task_Gen/data/final_missing_subtopics.csv @@ -0,0 +1,49 @@ +ACL,Access Control List fundamentals|Permission types and inheritance|File system ACL implementation|Network ACL configuration|Active Directory ACL management|ACL troubleshooting techniques|Performance considerations|Security best practices +APT,Advanced Persistent Threat characteristics|Attack lifecycle and techniques|Attribution and threat intelligence|Detection and response strategies|Case study analysis|Defensive measures|Incident response procedures|Prevention strategies +AUTHENTICATION,Authentication factors and methods|Multi-factor authentication|Single sign-on implementation|Identity providers and federation|Authentication protocols|Token-based authentication|Biometric authentication|Risk-based authentication +Antimalware,Malware detection techniques|Signature-based vs heuristic analysis|Real-time protection mechanisms|Cloud-based threat intelligence|Performance optimization|False positive management|Enterprise deployment|Integration strategies +Antivirus,Virus detection algorithms|Scanning methodologies|Update and signature management|Quarantine procedures|Performance impact mitigation|Enterprise management|Endpoint integration|Threat response automation +Certificates,Digital certificate fundamentals|Certificate Authority hierarchy|Certificate lifecycle management|Public Key Infrastructure|Certificate validation processes|Revocation mechanisms|Certificate deployment|Troubleshooting procedures +Containment,Incident containment strategies|Network isolation techniques|System quarantine procedures|Damage limitation methods|Evidence preservation|Communication protocols|Resource allocation|Recovery planning +DATA PIPELINES,Pipeline architecture design|Data ingestion strategies|Transformation and processing|Quality assurance and validation|Monitoring and alerting|Error handling and recovery|Scalability considerations|Performance optimization +DJANGO,Django framework architecture|Model-View-Template pattern|ORM and database integration|URL routing and views|Template system and inheritance|Admin interface customization|Authentication and authorization|REST API development +DLP,Data Loss Prevention strategies|Content inspection techniques|Policy development and enforcement|Endpoint protection|Network monitoring|Cloud security integration|Incident response|Compliance reporting +EAP vs PEAP,Extensible Authentication Protocol|Protected EAP implementation|Authentication methods comparison|Wireless security integration|Certificate management|Configuration procedures|Troubleshooting techniques|Security considerations +EDR,Endpoint Detection and Response|Behavioral analysis techniques|Threat hunting capabilities|Incident response automation|Forensic data collection|Advanced threat detection|Integration with SIEM|Performance optimization +ELASTICSEARCH,Search and analytics engine|Index management and mapping|Query DSL and search operations|Cluster architecture and scaling|Data ingestion and pipelines|Monitoring and performance tuning|Security configuration|Kibana visualization +Eradication,Threat removal procedures|System cleaning and sanitization|Malware elimination techniques|Vulnerability remediation|Configuration hardening|Validation and verification|Documentation procedures|Prevention measures +Firewall & Nextgen Firewall,Traditional firewall functions|Next-generation firewall features|Application awareness and control|Intrusion prevention integration|Deep packet inspection|User identity integration|Threat intelligence feeds|Performance optimization +HIPS,Host-based Intrusion Prevention|Behavioral monitoring techniques|Policy configuration and tuning|Integration with endpoint security|Performance impact management|False positive reduction|Incident response integration|Compliance reporting +Host Based Firewall,Local firewall configuration|Rule management and policies|Application control|Network traffic filtering|Integration with security tools|Performance considerations|Troubleshooting techniques|Best practices +Identification,Threat identification techniques|Indicator analysis and correlation|Asset discovery and classification|Vulnerability identification|Risk assessment procedures|Intelligence gathering|Documentation standards|Validation processes +Kerberos,Authentication protocol fundamentals|Ticket-granting mechanisms|Key Distribution Center|Cross-realm authentication|Security considerations|Implementation best practices|Troubleshooting procedures|Integration strategies +Known vs Unknown,Threat classification methods|Signature-based detection|Zero-day threat analysis|Behavioral analysis techniques|Threat intelligence integration|Risk assessment procedures|Response strategies|Detection improvement +LDAP,Directory service fundamentals|Schema design and management|Authentication and authorization|Query operations and filters|Replication and high availability|Security configuration|Performance optimization|Integration patterns +LINUX,Operating system fundamentals|Command line proficiency|System administration|Package management|File system and permissions|Network configuration|Security hardening|Troubleshooting techniques +Lessons Learned,Post-incident analysis|Documentation procedures|Process improvement identification|Knowledge sharing mechanisms|Training development|Policy updates|Stakeholder communication|Continuous improvement +Local Auth,Local authentication methods|User account management|Password policies and enforcement|Privilege management|Security hardening|Audit and monitoring|Integration considerations|Best practices +MACHINE LEARNING,Algorithm fundamentals|Supervised and unsupervised learning|Model training and validation|Feature engineering|Performance evaluation|Deployment strategies|Ethical considerations|Continuous learning +MICROSERVICES,Architecture patterns and principles|Service decomposition strategies|Inter-service communication|Data management patterns|Deployment and orchestration|Monitoring and observability|Security considerations|Performance optimization +MYSQL,Database administration|Query optimization|Index management|Replication configuration|Backup and recovery|Performance tuning|Security hardening|Troubleshooting techniques +NIDS,Network Intrusion Detection|Traffic analysis techniques|Signature and anomaly detection|Sensor deployment strategies|Alert management and tuning|Performance optimization|Integration with SIEM|Incident response +NIPS,Network Intrusion Prevention|Inline deployment strategies|Attack blocking mechanisms|Performance considerations|Policy management|False positive reduction|High availability|Integration patterns +OAUTH,Authorization framework|Grant types and flows|Token management|Security considerations|Implementation best practices|API protection|Integration patterns|Troubleshooting procedures +POSITIONING,Strategic positioning concepts|Market analysis techniques|Competitive advantage|Brand differentiation|Value proposition development|Customer segmentation|Communication strategies|Performance measurement +POWER BI,Data visualization and analytics|Report development|Dashboard creation|Data modeling techniques|DAX formula usage|Service administration|Security and sharing|Performance optimization +Preparation,Incident response preparation|Plan development and testing|Team training and readiness|Tool and resource provisioning|Communication procedures|Documentation standards|Regular updates|Stakeholder engagement +RADIUS,Remote authentication service|Network access control|Policy enforcement|Integration strategies|Security considerations|Performance optimization|Troubleshooting techniques|High availability +REDIS,In-memory data structure store|Caching strategies|Data persistence options|Clustering and high availability|Performance optimization|Security configuration|Monitoring and troubleshooting|Integration patterns +Recovery,Disaster recovery planning|Backup and restoration|Business continuity|System recovery procedures|Data recovery techniques|Testing and validation|Communication protocols|Continuous improvement +SSO,Single Sign-On implementation|Identity provider integration|Federation protocols|Security considerations|User experience optimization|Administration and management|Troubleshooting procedures|Performance considerations +Sandboxing,Isolated execution environments|Malware analysis techniques|Application security testing|Performance impact assessment|Evasion detection|Integration strategies|Automation procedures|Result analysis +Security Skills and Knowledge,Cybersecurity fundamentals|Threat landscape awareness|Risk assessment methodologies|Security framework knowledge|Incident response capabilities|Compliance requirements|Continuous learning|Professional development +TABLEAU,Data visualization platform|Dashboard development|Data connection and modeling|Calculated fields and parameters|Interactive features|Performance optimization|Administration and security|Advanced analytics +Understand Basics of Forensics,Digital evidence principles|Chain of custody procedures|Forensic methodologies|Tool utilization|Legal considerations|Report writing|Expert testimony|Continuous education +Understand Common Exploit Frameworks,Framework architecture|Payload development|Target exploitation|Post-exploitation techniques|Evasion methods|Defensive considerations|Legal and ethical usage|Tool integration +Understand Common Hacking Tools,Tool categories and purposes|Reconnaissance tools|Exploitation frameworks|Post-exploitation utilities|Defensive applications|Legal considerations|Tool detection|Mitigation strategies +Understand Concept of Defense in Depth,Layered security approach|Security control categories|Risk mitigation strategies|Implementation planning|Integration considerations|Effectiveness measurement|Continuous improvement|Cost-benefit analysis +Understand Concept of Runbooks,Procedure documentation|Incident response playbooks|Operational procedures|Automation integration|Version control|Training materials|Regular updates|Effectiveness measurement +VirusTotal,File and URL analysis|Threat intelligence aggregation|API integration|Report interpretation|Automation workflows|Threat hunting applications|False positive management|Enterprise features +WPA vs WPA2 vs WPA3 vs WEP,Wireless security protocol evolution|Encryption method comparison|Authentication mechanisms|Vulnerability analysis|Implementation considerations|Performance impact|Migration strategies|Best practices +WPS,Wi-Fi Protected Setup|Security vulnerabilities|Attack vectors|Disable procedures|Alternative setup methods|Security implications|Troubleshooting|Best practices +Zero Day,Unknown vulnerability exploitation|Discovery and disclosure|Attack techniques|Detection challenges|Mitigation strategies|Threat intelligence|Response procedures|Prevention measures \ No newline at end of file diff --git a/backend/Using/Task_Gen/data/manual_subtopics.csv b/backend/Using/Task_Gen/data/manual_subtopics.csv new file mode 100644 index 00000000..7de66b93 --- /dev/null +++ b/backend/Using/Task_Gen/data/manual_subtopics.csv @@ -0,0 +1,89 @@ +concept,subtopics +FTP / SFTP,Understanding File Transfer Protocol basics|Setting up FTP servers|Configuring SFTP for secure transfers|FTP vs SFTP security differences|Active vs Passive FTP modes|FTP client configuration and usage|Troubleshooting FTP connection issues|FTP directory permissions and access control +DNS,DNS hierarchy and root servers|DNS record types (A AAAA CNAME MX)|DNS resolution process and queries|Configuring DNS servers|DNS caching and TTL concepts|DNS security and DNSSEC|Troubleshooting DNS issues|DNS load balancing techniques +HTTP,HTTP request and response structure|HTTP methods (GET POST PUT DELETE)|HTTP status codes and meanings|HTTP headers and their purposes|HTTP/1.1 vs HTTP/2 vs HTTP/3 differences|HTTPS and SSL/TLS integration|HTTP caching mechanisms|RESTful API design with HTTP +SSL / TLS,SSL/TLS handshake process|Certificate authorities and PKI|SSL certificate types and validation|TLS encryption algorithms and ciphers|SSL/TLS configuration best practices|Certificate installation and management|SSL/TLS troubleshooting|Perfect Forward Secrecy concepts +SSH,SSH key generation and management|SSH client and server configuration|SSH tunneling and port forwarding|SSH authentication methods|SSH security hardening|SSH file transfer with SCP and RSYNC|SSH agent and key forwarding|Troubleshooting SSH connections +White / Grey Listing,Email whitelist and greylist concepts|Implementing SPF whitelisting|DNS-based whitelisting techniques|Application-level whitelisting|IP address whitelist management|Firewall whitelist configuration|Greylist temporary blocking mechanisms|Whitelist bypass prevention +SMTP,SMTP protocol fundamentals|SMTP server configuration|Email routing and relay setup|SMTP authentication mechanisms|SMTP security and encryption|Email deliverability optimization|SMTP troubleshooting techniques|Anti-spam SMTP configurations +DMARC,DMARC policy creation and syntax|DMARC alignment requirements|DMARC reporting and analysis|SPF and DKIM integration with DMARC|DMARC deployment strategies|DMARC forensic reports|Email authentication troubleshooting|DMARC policy enforcement levels +IMAP,IMAP protocol fundamentals|IMAP vs POP3 differences|IMAP server configuration|IMAP folder synchronization|IMAP security and encryption|IMAP client configuration|IMAP performance optimization|Troubleshooting IMAP connectivity +SPF,SPF record syntax and mechanisms|SPF policy creation and testing|DNS SPF record configuration|SPF alignment and authentication|SPF record validation tools|SPF troubleshooting techniques|SPF policy optimization|SPF integration with other email security +POP3S,POP3 protocol basics|POP3S encryption setup|POP3 vs IMAP comparison|POP3 server configuration|POP3 client settings|POP3 message handling|POP3 security considerations|Migrating from POP3 to IMAP +Domain Keys,DomainKeys signature generation|DomainKeys DNS record setup|Public and private key management|DomainKeys vs DKIM differences|Email signing and verification|DomainKeys implementation|DomainKeys troubleshooting|Legacy email authentication methods +OSI Model,Physical layer fundamentals|Data link layer protocols|Network layer addressing|Transport layer protocols|Session layer management|Presentation layer encoding|Application layer services|OSI vs TCP/IP model comparison +Networking & Protocols,TCP and UDP protocol differences|Network packet structure|Protocol stack implementation|Network troubleshooting methodologies|Protocol analysis techniques|Network security protocols|Quality of Service (QoS)|Network performance optimization +Vercel,Vercel deployment pipeline|Next.js integration with Vercel|Environment variables configuration|Custom domains and SSL|Vercel Functions (serverless)|Build and deployment optimization|Monitoring and analytics|Vercel CLI usage +Cloudflare,DNS management with Cloudflare|CDN configuration and optimization|DDoS protection setup|SSL certificate management|Web Application Firewall (WAF)|Page rules and caching|Workers and Edge Functions|Analytics and performance monitoring +Azure Functions,Serverless function development|Trigger types and bindings|Azure Functions runtime versions|Local development and testing|Deployment and CI/CD integration|Monitoring and logging|Performance optimization|Cost management strategies +AWS Lambda,Lambda function creation and deployment|Event-driven architecture patterns|Lambda layers and dependencies|Cold start optimization techniques|Lambda security and IAM roles|Monitoring with CloudWatch|Lambda cost optimization|Serverless application patterns +Netlify,Static site deployment process|Git-based deployment workflows|Build configuration and optimization|Form handling and submissions|Netlify Functions implementation|Custom headers and redirects|Domain management and SSL|Analytics and performance monitoring +Provisioning,Infrastructure provisioning concepts|Automated provisioning tools|Cloud resource provisioning|Configuration management|Provisioning templates and scripts|Resource lifecycle management|Provisioning security best practices|Monitoring provisioned resources +OSCP,Penetration testing methodologies|Manual exploitation techniques|Buffer overflow exploitation|Web application security testing|Network service enumeration|Post-exploitation techniques|Report writing and documentation|Ethical hacking principles +CREST,Penetration testing standards|CREST certification pathways|Technical security assessment|Vulnerability assessment methodologies|Social engineering testing|Physical security testing|Reporting and communication|Professional ethics and conduct +CISSP,Information security governance|Asset security management|Security architecture and engineering|Communication and network security|Identity and access management|Security assessment and testing|Security operations management|Software development security +MacOS,MacOS system architecture|File system and directory structure|Terminal and command line usage|System preferences and configuration|Security features and settings|Application installation methods|Backup and recovery procedures|Troubleshooting common issues +Installation and Configuration,System requirements assessment|Pre-installation planning|Installation media preparation|Custom installation options|Post-installation configuration|Driver and software updates|System optimization settings|Configuration backup procedures +Different Versions and Differences,Version comparison methodologies|Compatibility assessment|Migration planning strategies|Feature comparison analysis|Performance benchmarking|Security improvement analysis|Upgrade path planning|Rollback procedures +Navigating using GUI and CLI,Graphical interface navigation|Command line interface basics|Keyboard shortcuts and hotkeys|File manager usage|System administration tools|Task management interfaces|Search and filtering techniques|Accessibility features +Understand Permissions,File system permissions|User and group management|Permission inheritance models|Access control lists (ACLs)|Special permissions and attributes|Permission troubleshooting|Security implications|Cross-platform permission differences +Installing Software and Applications,Package management systems|Software repositories|Dependency resolution|Installation verification|Software updates and patches|Uninstallation procedures|Portable application management|Security considerations +Performing CRUD on Files,Create file operations|Read and view file contents|Update and modify files|Delete and remove files|File copy and move operations|Batch file operations|File attribute management|File recovery techniques +Troubleshooting,Problem identification techniques|Systematic troubleshooting approach|Log file analysis|Diagnostic tool usage|Root cause analysis|Solution implementation|Testing and verification|Documentation and knowledge sharing +Common Commands,File and directory commands|System information commands|Process management commands|Network diagnostic commands|Text processing commands|Archive and compression commands|Permission and ownership commands|Help and documentation commands +Networking Knowledge,Network topology concepts|IP addressing and subnetting|Routing protocols and tables|Switching and VLANs|Network security fundamentals|Wireless networking principles|Network performance monitoring|Troubleshooting network issues +Understand the OSI Model,Layer 1 Physical specifications|Layer 2 Data Link protocols|Layer 3 Network addressing|Layer 4 Transport protocols|Layer 5 Session management|Layer 6 Presentation formatting|Layer 7 Application services|Inter-layer communication +Common Protocols and their Uses,HTTP/HTTPS web protocols|FTP file transfer protocols|SMTP email protocols|DNS name resolution|DHCP address assignment|SNMP network management|SSH secure remote access|Telnet remote terminal access +Common Ports and their Uses,Well-known port assignments|Registered port ranges|Dynamic port allocation|Port security considerations|Port scanning techniques|Firewall port configuration|Service port identification|Port conflict resolution +SSL and TLS Basics,Cryptographic handshake process|Certificate validation|Cipher suite negotiation|Public key infrastructure|SSL/TLS versions comparison|Certificate chain verification|Perfect forward secrecy|Common vulnerabilities +Basics of NAS and SAN,Network Attached Storage architecture|Storage Area Network design|File-level vs block-level access|RAID configuration options|Network protocols for storage|Performance optimization|Backup and disaster recovery|Storage capacity planning +Basics of Subnetting,IP address classes|Subnet mask calculation|CIDR notation usage|Network and broadcast addresses|Variable Length Subnet Masking|Subnetting best practices|Route summarization|Subnet design strategies +Public vs Private IP Addresses,RFC 1918 private address ranges|Public IP address allocation|NAT and PAT concepts|IPv4 address exhaustion|IPv6 addressing schemes|IP address planning|Security implications|Dynamic vs static addressing +localhost,Loopback interface concept|Local service testing|Development environment setup|Port binding on localhost|Security implications|Cross-platform localhost behavior|Localhost vs 127.0.0.1|Local networking troubleshooting +loopback,Loopback interface configuration|Network testing with loopback|Loopback address ranges|Virtual loopback interfaces|Routing with loopback|Loopback security considerations|Troubleshooting loopback issues|Loopback vs physical interfaces +CIDR,Classless Inter-Domain Routing notation|CIDR block allocation|Route aggregation techniques|CIDR vs classful addressing|Subnet calculation with CIDR|VLSM implementation|BGP and CIDR|Network planning with CIDR +subnet mask,Binary subnet mask representation|Decimal subnet mask notation|Subnet mask calculation methods|Variable length subnet masks|Subnet mask troubleshooting|Custom subnet mask creation|Subnet mask validation|Network design considerations +default gateway,Gateway configuration setup|Routing table entries|Gateway selection process|Multiple gateway scenarios|Gateway failover mechanisms|Default route configuration|Gateway performance optimization|Troubleshooting gateway issues +VLAN,Virtual LAN concepts|VLAN tagging protocols|Inter-VLAN routing|VLAN configuration on switches|VLAN security considerations|VLAN troubleshooting|Dynamic VLAN assignment|VLAN best practices +DMZ,Demilitarized Zone architecture|DMZ security policies|Firewall DMZ configuration|DMZ service deployment|Network segmentation strategies|DMZ monitoring and logging|DMZ access control|DMZ vulnerability management +ARP,Address Resolution Protocol operation|ARP table management|ARP spoofing attacks|Gratuitous ARP usage|ARP cache optimization|ARP troubleshooting techniques|Proxy ARP configuration|ARP security considerations +VM,Virtual machine architecture|Hypervisor types and features|VM resource allocation|VM networking configuration|VM storage management|VM security considerations|VM backup and recovery|VM performance optimization +DHCP,DHCP lease process|DHCP server configuration|DHCP reservation setup|DHCP option configuration|DHCP troubleshooting|DHCP failover and redundancy|DHCP security considerations|Dynamic DNS integration +NAT,Network Address Translation concepts|Static NAT configuration|Dynamic NAT operation|PAT (Port Address Translation)|NAT traversal techniques|NAT security implications|NAT performance considerations|NAT troubleshooting +IP,IP addressing fundamentals|IPv4 vs IPv6 comparison|IP packet structure|IP routing concepts|IP fragmentation handling|IP quality of service|IP security extensions|IP troubleshooting tools +Router,Router architecture and components|Routing table management|Dynamic routing protocols|Static route configuration|Router security hardening|Router performance optimization|Router troubleshooting|Router redundancy setup +Switch,Layer 2 switching concepts|MAC address learning|Spanning Tree Protocol|Switch port configuration|VLAN implementation|Switch security features|Switch troubleshooting|Switch stacking and bonding +VPN,VPN protocols and types|Site-to-site VPN setup|Remote access VPN configuration|VPN encryption methods|VPN authentication mechanisms|VPN troubleshooting|VPN performance optimization|VPN security best practices +MAN,Metropolitan Area Network design|MAN technologies and protocols|MAN vs WAN differences|MAN service provider options|MAN security considerations|MAN performance optimization|MAN cost analysis|MAN redundancy planning +LAN,Local Area Network architecture|LAN protocols and standards|Ethernet technology|LAN security implementation|LAN performance monitoring|LAN troubleshooting|Wireless LAN integration|LAN expansion strategies +WAN,Wide Area Network technologies|WAN connectivity options|WAN optimization techniques|WAN security implementations|WAN cost management|WAN redundancy design|WAN performance monitoring|WAN troubleshooting +WLAN,Wireless LAN standards|Access point deployment|Wireless security protocols|WLAN performance optimization|Wireless site surveys|WLAN troubleshooting|Guest network setup|Enterprise WLAN management +NTP,Network Time Protocol operation|NTP server hierarchy|Time synchronization accuracy|NTP security considerations|NTP troubleshooting|Chrony vs NTP comparison|GPS time source integration|NTP monitoring and logging +IPAM,IP Address Management systems|IP address allocation strategies|DHCP and DNS integration|IPAM database design|Automated IP discovery|IP address lifecycle management|IPAM reporting and analytics|IPAM security considerations +Star,Star topology advantages|Central hub requirements|Star network scalability|Fault tolerance in star networks|Cable management in star topology|Star topology troubleshooting|Cost analysis of star networks|Star topology security considerations +Ring,Ring topology operation|Token passing mechanisms|Ring network fault tolerance|Fiber optic ring networks|Ring topology troubleshooting|Ring network performance|SONET/SDH ring networks|Ring topology redundancy +Mesh,Mesh topology design|Full mesh vs partial mesh|Wireless mesh networks|Mesh routing protocols|Mesh network scalability|Self-healing mesh capabilities|Mesh topology cost analysis|Mesh network security +Bus,Bus topology fundamentals|Collision detection mechanisms|Bus network limitations|Coaxial cable bus networks|Bus topology troubleshooting|Legacy bus network migration|Bus network performance issues|Bus topology security vulnerabilities +RDP,Remote Desktop Protocol setup|RDP security hardening|RDP performance optimization|RDP licensing requirements|RDP troubleshooting|Alternative remote access solutions|RDP network requirements|RDP session management +FTP,File Transfer Protocol basics|FTP server configuration|FTP client usage|Active vs passive FTP modes|FTP security considerations|FTPS vs SFTP comparison|FTP automation scripting|FTP troubleshooting techniques +SFTP,SSH File Transfer Protocol setup|SFTP vs FTP security differences|SFTP client configuration|SFTP server hardening|SFTP key management|SFTP automation and scripting|SFTP performance optimization|SFTP troubleshooting +VMWare,VMware vSphere architecture|Virtual machine management|ESXi hypervisor configuration|vCenter Server administration|VMware networking concepts|Storage management with VMware|VMware security best practices|VMware performance optimization +VirtualBox,VirtualBox installation and setup|Virtual machine creation|VirtualBox networking modes|Shared folders and clipboard|VirtualBox guest additions|Snapshot management|VirtualBox CLI usage|VirtualBox troubleshooting +esxi,ESXi installation and configuration|ESXi networking setup|Virtual machine management|ESXi storage configuration|ESXi security hardening|ESXi monitoring and logging|ESXi backup strategies|ESXi troubleshooting +proxmox,Proxmox VE installation|Container and VM management|Proxmox clustering setup|Storage configuration|Network configuration|Backup and restore procedures|Proxmox web interface usage|High availability configuration +Hypervisor,Type 1 vs Type 2 hypervisors|Hypervisor architecture|Resource allocation and scheduling|Hardware virtualization support|Hypervisor security considerations|Performance optimization|Hypervisor migration|Virtualization troubleshooting +GuestOS,Guest operating system installation|Guest OS optimization|Integration services setup|Guest OS security hardening|Resource allocation for guests|Guest OS backup strategies|Cross-platform guest support|Guest OS troubleshooting +HostOS,Host operating system requirements|Host OS optimization for virtualization|Security hardening of host systems|Resource management|Host OS monitoring|Backup and disaster recovery|Host OS maintenance|Performance tuning +nslookup,DNS lookup command usage|Forward and reverse DNS queries|Query type specification|Nslookup troubleshooting|Interactive vs non-interactive mode|DNS server specification|Record type queries|Debugging DNS issues +iptables,Iptables rule syntax|Chain management (INPUT OUTPUT FORWARD)|Target actions (ACCEPT REJECT DROP)|NAT and port forwarding|Packet matching criteria|Iptables script automation|Firewall policy design|Iptables troubleshooting +Packet Sniffers,Network traffic capture techniques|Packet analysis methodologies|Protocol decoding|Traffic filtering and search|Performance impact considerations|Legal and ethical considerations|Popular packet sniffing tools|Network troubleshooting with sniffers +ipconfig,IP configuration display|Network adapter information|DNS cache management|DHCP lease renewal|Network troubleshooting with ipconfig|Command line options|Cross-platform alternatives|Network configuration validation +netstat,Network connection display|Listening port identification|Process and PID association|Network statistics viewing|TCP connection states|UDP connection monitoring|Routing table display|Network troubleshooting techniques +Port Scanners,Port scanning techniques|Stealth scanning methods|Service enumeration|Port scan interpretation|Nmap usage and options|Scan timing and performance|Legal and ethical considerations|Defense against port scans +ping,ICMP ping operation|Network connectivity testing|Ping response analysis|Continuous ping monitoring|Ping flood testing|IPv6 ping usage|Ping troubleshooting|Network latency measurement +dig,DNS lookup with dig command|Query type specification|Authoritative vs recursive queries|DNS server targeting|Output format options|Reverse DNS lookups|DNS troubleshooting with dig|Batch DNS queries +Protocol Analyzers,Network protocol analysis|Deep packet inspection|Traffic pattern recognition|Performance bottleneck identification|Security threat detection|Protocol compliance testing|Network forensics|Troubleshooting network issues +nmap,Network discovery techniques|Port scanning methodologies|Service version detection|Operating system fingerprinting|Vulnerability scanning|Nmap scripting engine|Stealth scanning techniques|Network security assessment +route,Routing table management|Static route configuration|Route addition and deletion|Route metrics and priorities|Default route setup|Route troubleshooting|Dynamic routing integration|Multi-homed routing +tcpdump,Packet capture with tcpdump|Capture filter expressions|Output format options|Real-time packet analysis|Capture file management|Network troubleshooting techniques|Performance considerations|Security monitoring +tracert,Route tracing methodology|Hop-by-hop analysis|Network path identification|Latency measurement|MTU discovery|IPv6 traceroute|Troubleshooting routing issues|Network topology mapping \ No newline at end of file diff --git a/backend/Using/Task_Gen/data/manual_subtopics_batch2.csv b/backend/Using/Task_Gen/data/manual_subtopics_batch2.csv new file mode 100644 index 00000000..5338002e --- /dev/null +++ b/backend/Using/Task_Gen/data/manual_subtopics_batch2.csv @@ -0,0 +1,77 @@ +Understand Basics of Forensics,Digital evidence collection procedures|Chain of custody documentation|File system analysis techniques|Memory dump acquisition and analysis|Network forensics methodologies|Mobile device forensics|Timeline analysis and reconstruction|Forensic reporting and testimony +Basics and Concepts of Threat Hunting,Hypothesis-driven hunting approaches|Threat intelligence integration|Behavioral analysis techniques|IOC and IOA identification|SIEM and log analysis for hunting|Network traffic analysis|Endpoint detection and response|Threat hunting team organization +Basics of Vulnerability Management,Vulnerability assessment methodologies|Vulnerability scanning tools and techniques|Risk scoring and prioritization|Patch management workflows|Vulnerability lifecycle management|False positive identification|Remediation tracking and validation|Compliance and reporting requirements +Basics of Reverse Engineering,Static analysis techniques|Dynamic analysis methods|Disassembly and decompilation|Binary analysis tools|Malware reverse engineering|Protocol reverse engineering|Code obfuscation analysis|Vulnerability research techniques +Penetration Testing Rules of Engagement,Scope definition and boundaries|Authorization and legal frameworks|Testing methodologies and standards|Communication protocols|Escalation procedures|Documentation requirements|Post-testing cleanup procedures|Ethical considerations and limitations +Perimiter vs DMZ vs Segmentation,Network perimeter security concepts|DMZ architecture and implementation|Network segmentation strategies|Micro-segmentation techniques|Zero trust network principles|VLAN and subnet isolation|Firewall placement and configuration|Security zone design +Core Concepts of Zero Trust,Zero trust architecture principles|Identity verification requirements|Continuous authentication methods|Least privilege access controls|Network segmentation strategies|Device trust and compliance|Data protection and encryption|Zero trust implementation planning +Roles of Compliance and Auditors,Regulatory compliance frameworks|Audit planning and execution|Control testing methodologies|Risk assessment and management|Compliance monitoring and reporting|Remediation tracking|Auditor independence requirements|Documentation and evidence management +Understand the Definition of Risk,Risk identification methodologies|Qualitative vs quantitative risk analysis|Risk assessment frameworks|Risk tolerance and appetite|Risk mitigation strategies|Risk monitoring and review|Business impact analysis|Risk communication techniques +Understand Backups and Resiliency,Backup strategy planning|Recovery point and time objectives|Backup types and methodologies|Disaster recovery planning|Business continuity management|High availability design|Failover and failback procedures|Testing and validation processes +Cyber Kill Chain,Reconnaissance phase analysis|Weaponization stage identification|Delivery mechanism detection|Exploitation techniques|Installation and persistence|Command and control detection|Actions on objectives|Kill chain disruption strategies +MFA & 2FA,Authentication factor categories|SMS and voice-based authentication|App-based authenticator setup|Hardware token implementation|Biometric authentication methods|Risk-based authentication|MFA bypass techniques|User experience considerations +Operating System Hardening,Security configuration baselines|Service and feature reduction|User account management|File system permissions|Network service configuration|Logging and monitoring setup|Update and patch management|Security tool integration +Understand Concept of Isolation,Process isolation mechanisms|Network isolation techniques|Container and VM isolation|Application sandboxing|Data isolation strategies|Physical isolation requirements|Cloud isolation models|Isolation testing and validation +Basics of IDS and IPS,Intrusion detection methodologies|Signature-based vs anomaly detection|Network vs host-based systems|IPS deployment strategies|Rule and signature management|False positive reduction|Performance optimization|Integration with SIEM systems +Honeypots,Honeypot deployment strategies|Low vs high interaction systems|Network honeypot configuration|Application honeypot setup|Data collection and analysis|Legal and ethical considerations|Honeypot maintenance|Threat intelligence generation +Authentication vs Authorization,Authentication mechanisms|Authorization models and frameworks|Role-based access control|Attribute-based access control|Single sign-on implementation|Federation and trust relationships|Access control testing|Privilege management +Blue / Red / Purple Teams,Blue team defensive operations|Red team offensive techniques|Purple team collaboration|Exercise planning and execution|Threat simulation methodologies|Skills development and training|Tool and technique sharing|Performance measurement +False Negative / False Positive,Detection accuracy metrics|Tuning and optimization techniques|Cost-benefit analysis|Alert fatigue management|Baseline establishment|Statistical analysis methods|Quality assurance processes|Continuous improvement strategies +True Negative / True Positive,Classification accuracy assessment|Confusion matrix analysis|Precision and recall metrics|ROC curve interpretation|Model validation techniques|Performance benchmarking|Alert quality measurement|Decision threshold optimization +"Basics of Threat Intel, OSINT",Threat intelligence lifecycle|OSINT collection methodologies|Source evaluation and validation|Intelligence analysis techniques|Indicator extraction and sharing|Threat actor profiling|Attribution analysis|Intelligence dissemination +Understand Handshakes,TCP three-way handshake|TLS/SSL handshake process|Authentication handshakes|Key exchange mechanisms|Handshake optimization|Troubleshooting connection issues|Security considerations|Performance impact analysis +Understand CIA Triad,Confidentiality protection methods|Integrity assurance techniques|Availability management strategies|Risk assessment frameworks|Security control implementation|Compliance and governance|Incident response procedures|Security awareness training +Privilege Escalation,Horizontal privilege escalation|Vertical privilege escalation|Windows privilege escalation|Linux privilege escalation|Web application privilege escalation|Database privilege escalation|Prevention and detection techniques|Post-exploitation techniques +Web Based Attacks and OWASP10,Injection attack techniques|Broken authentication exploitation|Sensitive data exposure|XML external entity attacks|Broken access control|Security misconfiguration|Cross-site scripting (XSS)|Insecure deserialization +Learn how Malware works and Types,Virus replication mechanisms|Worm propagation methods|Trojan horse techniques|Ransomware encryption|Spyware data collection|Adware distribution|Rootkit hiding techniques|Advanced persistent threats +curl,HTTP request methods with curl|Authentication mechanisms|Cookie and session handling|File upload and download|SSL certificate verification|Proxy configuration|Scripting and automation|Troubleshooting connection issues +hping,TCP packet crafting|UDP packet generation|ICMP packet construction|Network reconnaissance|Firewall testing|DoS attack simulation|Traceroute functionality|Performance testing +cat,File content display|Multiple file concatenation|Standard input processing|Binary file handling|Pipe and redirection usage|Text processing workflows|Script integration|Performance considerations +dd,Block-level data copying|Disk imaging and cloning|Data conversion options|Progress monitoring|Error handling|Performance optimization|Forensic applications|Backup and recovery +head,File beginning display|Line count specification|Byte count options|Multiple file processing|Pipe integration|Log file analysis|Script automation|Performance considerations +grep,Pattern matching fundamentals|Regular expression usage|File search operations|Recursive directory searching|Case sensitivity options|Output formatting|Performance optimization|Advanced pattern techniques +wireshark,Packet capture setup|Protocol analysis|Display filter creation|Network troubleshooting|Security analysis|Performance analysis|Custom dissector development|Capture file management +winhex,Hex editing fundamentals|Binary file analysis|Data recovery techniques|Disk sector editing|Template and script usage|Forensic applications|Data comparison|File signature analysis +memdump,Memory acquisition techniques|Live memory analysis|Process memory extraction|Kernel memory dumping|Memory image formats|Analysis tool integration|Volatile data preservation|Forensic best practices +FTK Imager,Disk imaging procedures|Evidence acquisition|Hash verification|Preview capabilities|Registry analysis|File system examination|Report generation|Chain of custody documentation +autopsy,Digital forensics workflow|Case management|File system analysis|Timeline creation|Keyword searching|Hash database integration|Report generation|Plugin development +tail,File end monitoring|Real-time log viewing|Line count specification|Multiple file tracking|Rotation handling|Pipe integration|Performance optimization|System monitoring +Salting,Password salt generation|Hash salt implementation|Rainbow table prevention|Salt storage strategies|Cryptographic best practices|Salt uniqueness requirements|Performance considerations|Security analysis +Hashing,Hash function properties|Cryptographic hash algorithms|Message digest creation|Hash collision analysis|Digital signature integration|Password hashing|File integrity verification|Performance optimization +Key Exchange,Diffie-Hellman protocol|RSA key exchange|Elliptic curve methods|Perfect forward secrecy|Key agreement protocols|Security considerations|Implementation best practices|Performance optimization +PKI,Certificate authority hierarchy|Digital certificate lifecycle|Certificate validation|Revocation mechanisms|Trust store management|Key escrow considerations|Cross-certification|PKI deployment strategies +Private vs Public Keys,Asymmetric cryptography concepts|Key pair generation|Digital signature creation|Encryption and decryption|Key management practices|Security considerations|Performance implications|Use case selection +Obfuscation,Code obfuscation techniques|Anti-reverse engineering methods|Binary packing|Control flow obfuscation|Data obfuscation strategies|Performance impact analysis|Deobfuscation techniques|Security effectiveness assessment +ATT&CK,MITRE ATT&CK framework|Tactic and technique mapping|Threat actor profiling|Detection rule development|Red team exercise planning|Security control assessment|Intelligence analysis|Framework implementation +Kill Chain,Cyber kill chain methodology|Attack phase identification|Defensive strategies|Intelligence requirements|Threat hunting applications|Incident response integration|Risk assessment|Mitigation planning +Diamond Model,Adversary capability analysis|Infrastructure identification|Victim characterization|Event correlation|Threat intelligence development|Attribution analysis|Defensive planning|Intelligence sharing +ISO,ISO 27001 implementation|Information security management|Risk assessment procedures|Control framework selection|Audit and compliance|Continuous improvement|Documentation requirements|Certification process +RMF,Risk Management Framework steps|Categorization procedures|Control selection process|Implementation guidance|Assessment methodologies|Authorization decisions|Monitoring strategies|Framework integration +CIS,CIS Controls implementation|Cybersecurity framework|Control prioritization|Maturity assessment|Implementation guidance|Measurement and metrics|Compliance mapping|Continuous improvement +CSF,NIST Cybersecurity Framework|Identify function implementation|Protect function strategies|Detect function capabilities|Respond function procedures|Recover function planning|Framework adoption|Maturity assessment +SIEM,Security event correlation|Log collection and normalization|Incident detection rules|Dashboard and reporting|Threat intelligence integration|Use case development|Tuning and optimization|Compliance reporting +SOAR,Security orchestration platforms|Automated response workflows|Playbook development|Integration capabilities|Incident response automation|Threat intelligence automation|Case management|Performance metrics +ParrotOS,Penetration testing toolkit|Security assessment tools|Digital forensics capabilities|Privacy and anonymity tools|System customization|Tool integration|Workflow optimization|Update management +Kali Linux,Penetration testing distribution|Information gathering tools|Vulnerability assessment|Web application testing|Wireless security testing|Digital forensics tools|Exploitation frameworks|Post-exploitation tools +LOLBAS,Living off the land techniques|Legitimate tool abuse|Windows binary exploitation|PowerShell living off land|Command line evasion|Detection evasion techniques|Incident response challenges|Defensive strategies +Event Logs,Windows event log analysis|Security event correlation|Log parsing techniques|Threat hunting with logs|Incident investigation|Log retention policies|SIEM integration|Forensic analysis +syslogs,Syslog protocol standards|Log forwarding configuration|Centralized logging setup|Log parsing and analysis|Security monitoring|Troubleshooting techniques|Performance optimization|Compliance requirements +netflow,Network flow monitoring|Flow data collection|Traffic analysis techniques|Security monitoring|Capacity planning|Performance optimization|Tool integration|Anomaly detection +Packet Captures,Network traffic capture|Protocol analysis|Security investigation|Performance troubleshooting|Capture optimization|Storage management|Analysis techniques|Legal considerations +Firewall Logs,Log format understanding|Security event analysis|Traffic pattern identification|Incident investigation|Compliance reporting|Performance monitoring|Alert correlation|Automation techniques +MAC-based,Media Access Control filtering|MAC address management|Wireless security implementation|Network access control|Spoofing prevention|Device identification|Authentication integration|Limitations and bypasses +NAC-based,Network Access Control deployment|Device posture assessment|Quarantine procedures|Guest network management|Compliance enforcement|Integration strategies|Troubleshooting techniques|Performance considerations +Port Blocking,Firewall port configuration|Service restriction policies|Application control|Security hardening|Network segmentation|Performance impact|Troubleshooting connectivity|Exception management +Group Policy,Active Directory policy management|Security configuration|User environment control|Software deployment|Registry modification|Troubleshooting techniques|Best practices|Performance optimization +ACLs,Access Control List configuration|Permission management|File system security|Network access control|Troubleshooting access issues|Inheritance concepts|Performance considerations|Security best practices +Sinkholes,DNS sinkhole implementation|Malware communication blocking|Threat intelligence integration|Network traffic redirection|Monitoring and analysis|Performance considerations|False positive management|Legal considerations +Patching,Patch management lifecycle|Vulnerability assessment|Testing procedures|Deployment strategies|Rollback procedures|Compliance tracking|Automation techniques|Risk assessment +Jump Server,Privileged access management|Secure remote access|Session recording|Access control implementation|Monitoring and auditing|High availability setup|Security hardening|Troubleshooting connectivity +Endpoint Security,Endpoint protection platforms|Malware detection|Behavioral analysis|Device compliance|Remote management|Incident response|Performance optimization|Integration strategies +FTP vs SFTP,Protocol security comparison|Authentication mechanisms|Encryption implementation|Port usage differences|Firewall configuration|Performance considerations|Migration strategies|Use case selection +SSL vs TLS,Protocol version differences|Security improvements|Cipher suite evolution|Vulnerability mitigation|Configuration best practices|Performance optimization|Compatibility considerations|Migration planning +IPSEC,IPSec protocol suite|VPN implementation|Encryption algorithms|Authentication headers|Security associations|Tunnel vs transport mode|Configuration procedures|Troubleshooting techniques +DNSSEC,DNS Security Extensions|Digital signature validation|Trust anchor management|Zone signing procedures|Validation process|Implementation challenges|Performance impact|Troubleshooting techniques +LDAPS,LDAP over SSL implementation|Certificate management|Secure authentication|Directory service security|Configuration procedures|Performance optimization|Troubleshooting techniques|Migration strategies +SRTP,Secure Real-time Transport Protocol|Voice over IP security|Key management|Encryption algorithms|Implementation procedures|Performance considerations|Interoperability issues|Troubleshooting techniques +S/MIME,Secure email messaging|Digital signatures|Email encryption|Certificate management|Client configuration|Interoperability considerations|Key management|Troubleshooting issues \ No newline at end of file diff --git a/backend/Using/Task_Gen/data/manual_subtopics_batch3.csv b/backend/Using/Task_Gen/data/manual_subtopics_batch3.csv new file mode 100644 index 00000000..470fd0dd --- /dev/null +++ b/backend/Using/Task_Gen/data/manual_subtopics_batch3.csv @@ -0,0 +1,88 @@ +VirusTotal,File and URL scanning procedures|Malware analysis integration|API usage and automation|Community intelligence leveraging|False positive identification|Threat hunting applications|Report interpretation|Enterprise deployment +Joe Sandbox,Dynamic malware analysis|Sandbox environment setup|Behavioral analysis reports|API integration|Custom analysis configurations|Threat intelligence extraction|Report customization|Performance optimization +any.run,Interactive malware analysis|Real-time behavior monitoring|Network traffic analysis|Registry and file monitoring|Screenshot and video capture|API automation|Threat intelligence integration|Analysis report generation +urlvoid,URL reputation checking|Malicious website detection|API integration|Threat intelligence feeds|False positive handling|Automated scanning workflows|Report analysis|Security tool integration +urlscan,Website analysis and screenshots|Malicious content detection|DOM analysis|Network request monitoring|API automation|Threat hunting applications|Report interpretation|Integration strategies +WHOIS,Domain registration lookup|Contact information retrieval|Historical WHOIS data|Privacy protection analysis|Threat intelligence applications|API integration|Automation techniques|Investigation procedures +Phishing,Email-based social engineering|Phishing campaign identification|Email analysis techniques|URL analysis procedures|User awareness training|Technical countermeasures|Incident response procedures|Threat intelligence integration +Whishing,Voice-based social engineering|Phone call attack vectors|Caller ID spoofing|Social manipulation techniques|Detection strategies|Prevention measures|Incident response|User education +Whaling,Executive targeting techniques|High-value target identification|Advanced social engineering|Business email compromise|Detection strategies|Executive protection|Incident response|Awareness training +Smishing,SMS-based phishing attacks|Mobile threat vectors|Text message analysis|Mobile security measures|User awareness training|Technical countermeasures|Incident response|Threat intelligence +Spam vs Spim,Email spam identification|Instant messaging spam|Filtering mechanisms|Anti-spam technologies|User education|Legal considerations|Threat intelligence|Prevention strategies +Shoulder Surfing,Physical observation techniques|Visual eavesdropping methods|Prevention strategies|Environmental awareness|Screen privacy protection|Behavioral countermeasures|Detection techniques|Security awareness +Dumpster Diving,Physical information gathering|Document disposal security|Privacy protection measures|Information classification|Secure disposal procedures|Detection strategies|Physical security controls|Awareness training +Tailgating,Physical access control bypassing|Social engineering techniques|Access control weaknesses|Prevention strategies|Security awareness training|Physical security measures|Detection systems|Incident response +Social Engineering,Human psychology exploitation|Manipulation techniques|Trust building strategies|Information elicitation|Prevention and awareness|Technical countermeasures|Incident response|Training programs +Reconnaissance,Information gathering techniques|Open source intelligence|Network enumeration|Social media intelligence|Technical reconnaissance|Passive vs active methods|Threat modeling|Defensive strategies +Impersonation,Identity deception techniques|Authority figure exploitation|Digital impersonation|Voice and communication mimicking|Detection strategies|Prevention measures|Incident response|Legal considerations +Watering Hole Attack,Targeted website compromise|Victim profiling techniques|Exploit kit deployment|Detection strategies|Prevention measures|Incident response|Threat intelligence|Defensive tactics +Drive by Attack,Malicious website exploitation|Browser vulnerability exploitation|Exploit kit analysis|Detection techniques|Prevention strategies|Web security measures|Incident response|Threat hunting +Typo Squatting,Domain name exploitation|Brand impersonation|User misdirection techniques|Detection strategies|Prevention measures|Legal remedies|Monitoring techniques|Brand protection +Brute Force vs Password Spray,Password attack methodologies|Attack vector differences|Detection strategies|Prevention techniques|Account lockout policies|Authentication strengthening|Monitoring approaches|Incident response +DoS vs DDoS,Denial of service concepts|Distributed attack coordination|Attack vector analysis|Mitigation strategies|Network protection|Incident response|Recovery procedures|Prevention techniques +MITM,Man-in-the-middle attack vectors|Interception techniques|Certificate manipulation|Detection strategies|Prevention measures|Encryption importance|Network security|Incident response +Spoofing,Identity falsification techniques|IP address spoofing|Email spoofing methods|DNS spoofing attacks|Detection strategies|Prevention measures|Authentication mechanisms|Incident response +Evil Twin,Rogue wireless access point|Network impersonation|Credential harvesting|Detection techniques|Prevention strategies|Wireless security measures|User education|Incident response +DNS Poisoning,DNS cache manipulation|Malicious redirection|Attack vectors|Detection techniques|Prevention strategies|DNS security measures|Incident response|Recovery procedures +Deauth Attack,Wireless deauthentication|802.11 protocol exploitation|Attack execution|Detection methods|Prevention strategies|Wireless security hardening|Monitoring techniques|Incident response +VLAN Hopping,VLAN security bypass|Switch exploitation|Attack methodologies|Detection techniques|Prevention strategies|Network segmentation|Security hardening|Incident response +Rogue Access Point,Unauthorized wireless devices|Network infiltration|Detection techniques|Prevention strategies|Wireless security policies|Monitoring systems|Incident response|Physical security +Buffer Overflow,Memory corruption exploitation|Stack-based overflows|Heap-based overflows|Exploit development|Detection techniques|Prevention strategies|Code security|Vulnerability assessment +Memory Leak,Resource management failures|Memory allocation issues|Performance impact|Detection techniques|Prevention strategies|Code review practices|Testing methodologies|Debugging techniques +XSS,Cross-site scripting vectors|Reflected XSS attacks|Stored XSS vulnerabilities|DOM-based XSS|Detection techniques|Prevention strategies|Input validation|Output encoding +SQL Injection,Database query manipulation|Attack vector analysis|Blind injection techniques|Union-based attacks|Detection methods|Prevention strategies|Secure coding practices|Database security +CSRF,Cross-site request forgery|Attack vector analysis|Token-based protection|Same-origin policy|Detection techniques|Prevention strategies|Secure development|Testing methodologies +Replay Attack,Session replay exploitation|Token reuse attacks|Detection techniques|Prevention strategies|Cryptographic countermeasures|Session management|Security protocols|Incident response +Pass the Hash,Credential reuse attacks|Windows authentication exploitation|Lateral movement techniques|Detection strategies|Prevention measures|Credential protection|Monitoring techniques|Incident response +Directory Traversal,Path manipulation attacks|File system access bypass|Attack vector analysis|Detection techniques|Prevention strategies|Input validation|Access controls|Security testing +Stakeholders,Stakeholder identification|Interest analysis|Communication strategies|Engagement planning|Conflict resolution|Requirements gathering|Project success factors|Relationship management +HR,Human resource management|Recruitment and selection|Performance management|Employee relations|Compensation and benefits|Training and development|Legal compliance|Organizational development +Legal,Legal compliance requirements|Regulatory frameworks|Contract management|Intellectual property|Privacy laws|Risk management|Litigation support|Policy development +Compliance,Regulatory requirement management|Compliance framework implementation|Audit preparation|Risk assessment|Policy development|Training programs|Monitoring and reporting|Remediation procedures +Management,Leadership principles|Strategic planning|Team management|Performance management|Communication skills|Decision making|Resource allocation|Change management +Cloud Skills and Knowledge,Cloud service models|Deployment models|Cloud architecture|Security considerations|Cost optimization|Migration strategies|Governance frameworks|Service management +Understand the Concept of Security in the Cloud,Shared responsibility model|Cloud security frameworks|Identity and access management|Data protection|Network security|Compliance requirements|Incident response|Security monitoring +Understand the basics and general flow of deploying in the cloud,Cloud deployment models|Infrastructure provisioning|Application deployment|CI/CD pipelines|Configuration management|Monitoring setup|Scaling strategies|Cost optimization +Understand the differences between cloud and on-premises,Infrastructure ownership|Cost models|Scalability differences|Security responsibilities|Compliance considerations|Performance characteristics|Management approaches|Migration strategies +Understand the concept of Infrastructure as Code,IaC principles and benefits|Declarative vs imperative approaches|Version control integration|Infrastructure automation|Testing strategies|Deployment pipelines|Configuration management|Best practices +Understand the Concept of Serverless,Function as a Service concepts|Event-driven architecture|Serverless frameworks|Cold start optimization|Cost models|Scaling characteristics|Monitoring strategies|Security considerations +SaaS,Software as a Service models|Multi-tenancy architecture|Subscription management|Integration strategies|Data security|Compliance considerations|Vendor evaluation|Migration planning +PaaS,Platform as a Service offerings|Development environment|Application deployment|Service integration|Scaling mechanisms|Vendor lock-in considerations|Cost optimization|Security responsibilities +IaaS,Infrastructure as a Service models|Virtual machine management|Storage services|Network configuration|Security responsibilities|Cost management|Resource optimization|Service level agreements +Private,Private cloud architecture|On-premises deployment|Security advantages|Cost considerations|Scalability limitations|Management overhead|Compliance benefits|Hybrid integration +Public,Public cloud services|Multi-tenant environments|Cost advantages|Scalability benefits|Security considerations|Vendor dependencies|Service availability|Compliance challenges +Hybrid,Hybrid cloud architecture|Workload distribution|Data synchronization|Network connectivity|Security integration|Management complexity|Cost optimization|Migration strategies +GCP,Google Cloud Platform services|Compute engine management|Cloud storage solutions|BigQuery analytics|Kubernetes engine|Identity and access management|Networking services|Cost optimization +Dropbox,File synchronization services|Collaboration features|Security controls|API integration|Business administration|Compliance features|Mobile access|Storage management +Box,Enterprise file sharing|Collaboration workflows|Security and compliance|API development|Administrative controls|Integration capabilities|Mobile access|Governance features +OneDrive,Microsoft file storage|Office 365 integration|Synchronization features|Sharing and collaboration|Security controls|Administrative management|Mobile access|Business features +Google Drive,File storage and sharing|Google Workspace integration|Collaboration features|API development|Security controls|Administrative management|Mobile access|Backup solutions +GTFOBINS,Unix binary exploitation|Living off the land techniques|Privilege escalation methods|File read/write capabilities|Command execution|Bypass techniques|Detection strategies|Defensive measures +WADCOMS,Windows command reference|Attack technique documentation|Post-exploitation commands|Privilege escalation|Persistence mechanisms|Defense evasion|Collection techniques|Exfiltration methods +ORACLE,Oracle database architecture|SQL query optimization|PL/SQL programming|Database administration|Performance tuning|Security configuration|Backup and recovery|High availability +TRANSACTIONS,Database transaction concepts|ACID properties|Transaction isolation levels|Concurrency control|Deadlock handling|Performance optimization|Distributed transactions|Error handling +DATA-DRIVEN DECISION MAKING,Data collection strategies|Analysis methodologies|Statistical interpretation|Visualization techniques|Business intelligence|Performance metrics|Decision frameworks|Continuous improvement +AGILE,Agile methodology principles|Scrum framework implementation|Sprint planning and execution|User story development|Daily standups|Retrospectives|Continuous improvement|Team collaboration +CONFLUENCE,Wiki platform administration|Content creation and organization|Collaboration workflows|Template development|Permission management|Integration capabilities|Reporting features|Maintenance procedures +DOCKER,Container fundamentals|Image creation and management|Dockerfile best practices|Container orchestration basics|Networking configurations|Volume management|Security hardening|Troubleshooting techniques +EMOTIONAL INTELLIGENCE,Self-awareness development|Emotion regulation|Empathy and social awareness|Relationship management|Communication skills|Conflict resolution|Leadership effectiveness|Team dynamics +JENKINS,CI/CD pipeline creation|Build automation|Plugin management|Security configuration|Distributed builds|Pipeline as code|Integration strategies|Troubleshooting techniques +JIRA,Project management setup|Issue tracking workflows|Custom field configuration|Reporting and dashboards|Integration capabilities|User management|Automation rules|Performance optimization +KUBERNETES,Container orchestration fundamentals|Cluster architecture|Pod and service management|Configuration management|Resource management|Security best practices|Monitoring and logging|Troubleshooting techniques +PERFORMANCE METRICS,KPI identification and definition|Measurement methodologies|Data collection strategies|Analysis techniques|Reporting and visualization|Continuous monitoring|Improvement planning|Stakeholder communication +SCRUM,Scrum framework fundamentals|Role definitions|Ceremony implementation|Artifact management|Sprint execution|Backlog refinement|Team dynamics|Continuous improvement +SPLUNK,Log data ingestion|Search and analysis|Dashboard creation|Alert configuration|Data modeling|App development|Security use cases|Performance optimization +STRATEGIC THINKING,Vision development|Environmental scanning|Strategic analysis|Goal setting|Resource allocation|Risk assessment|Implementation planning|Performance measurement +PROGRAMMING SKILLS,Algorithm design|Data structure implementation|Code organization|Debugging techniques|Version control|Testing methodologies|Documentation practices|Continuous learning +STATISTICS,Descriptive statistics|Inferential statistics|Probability theory|Hypothesis testing|Regression analysis|Statistical software|Data interpretation|Research methodology +DISTRIBUTED SYSTEMS,System architecture design|Consistency models|Partitioning strategies|Replication techniques|Consensus algorithms|Fault tolerance|Performance optimization|Monitoring strategies +ORCHESTRATION,Workflow automation|Service coordination|Resource management|Dependency handling|Error recovery|Scaling strategies|Monitoring integration|Performance optimization +FLINK,Stream processing fundamentals|Event time processing|State management|Window operations|Fault tolerance|Deployment strategies|Performance tuning|Monitoring and debugging +KAFKA,Message broker architecture|Topic and partition management|Producer and consumer configuration|Stream processing|Cluster management|Security configuration|Performance optimization|Monitoring strategies +SCALA,Functional programming concepts|Object-oriented features|Type system|Collection operations|Concurrent programming|Build tools (SBT)|Testing frameworks|Performance optimization +GENERATIVE AI,Large language model concepts|Prompt engineering techniques|Fine-tuning strategies|Evaluation methodologies|Ethical considerations|Deployment strategies|Performance optimization|Use case development +CASSANDRA,NoSQL database concepts|Data modeling strategies|Cluster architecture|Replication strategies|Consistency levels|Performance tuning|Backup and recovery|Monitoring techniques +NOSQL DATABASES,Database model comparison|Document databases|Key-value stores|Column-family databases|Graph databases|Scalability patterns|Consistency models|Use case selection +NETWORKING,Network protocols|TCP/IP fundamentals|Routing and switching|Network security|Performance optimization|Troubleshooting techniques|Network design|Monitoring strategies +SPARK,Distributed computing fundamentals|RDD and DataFrame operations|Spark SQL|Streaming processing|Machine learning integration|Cluster management|Performance optimization|Debugging techniques +DATA STRUCTURES AND ALGORITHMS,Array and list operations|Tree and graph algorithms|Sorting and searching|Hash tables|Dynamic programming|Complexity analysis|Algorithm optimization|Problem-solving strategies \ No newline at end of file diff --git a/backend/Using/Task_Gen/data/manual_subtopics_batch4_final.csv b/backend/Using/Task_Gen/data/manual_subtopics_batch4_final.csv new file mode 100644 index 00000000..e5760fa6 --- /dev/null +++ b/backend/Using/Task_Gen/data/manual_subtopics_batch4_final.csv @@ -0,0 +1,85 @@ +DJANGO,Django project structure|Model-View-Template architecture|Django ORM and database integration|URL routing and view functions|Template system and inheritance|Django admin interface|Authentication and authorization|Forms and validation|Static files and media handling|Django REST framework +FASTAPI,FastAPI application structure|Automatic API documentation|Type hints and validation|Dependency injection system|Authentication and security|Async programming support|Database integration|Testing strategies|Deployment and performance|API versioning +FLASK,Flask application structure|Routing and view functions|Jinja2 templating|Request and response handling|Session management|Blueprint organization|Database integration with SQLAlchemy|Error handling|Testing and debugging|Deployment strategies +MLOPS,Machine learning lifecycle management|Model versioning and tracking|Continuous integration for ML|Model deployment strategies|Monitoring and observability|Data pipeline automation|Feature store management|Model governance|A/B testing for models|Infrastructure automation +PYTORCH,Tensor operations and autograd|Neural network construction|Dataset and DataLoader usage|Training loop implementation|Model saving and loading|GPU acceleration|Distributed training|Custom layers and functions|Model optimization|Debugging techniques +REACT NATIVE,Cross-platform mobile development|Component architecture|Navigation implementation|State management|Native module integration|Performance optimization|Debugging and testing|App store deployment|Platform-specific code|Animation and gestures +MATHEMATICS,Linear algebra fundamentals|Calculus concepts|Statistics and probability|Discrete mathematics|Mathematical modeling|Optimization techniques|Graph theory|Number theory|Logic and proofs|Applied mathematics +ANDROID,Android app architecture|Activity and Fragment lifecycle|UI design with XML and Compose|Data storage options|Networking and APIs|Background processing|Permissions and security|Testing strategies|App publishing|Performance optimization +ERROR HANDLING,Exception handling patterns|Error logging strategies|Graceful degradation|User error messaging|Error recovery mechanisms|Debugging techniques|Error monitoring tools|Testing error scenarios|Documentation practices|Best practices +JAVA,Object-oriented programming|Java syntax and fundamentals|Collections framework|Multithreading and concurrency|Exception handling|I/O operations|Generics and annotations|Design patterns|Testing with JUnit|Build tools and IDEs +UNIT TESTING,Testing fundamentals|Test-driven development|Test case design|Mocking and stubbing|Test automation|Code coverage analysis|Integration testing|Performance testing|Testing frameworks|Continuous testing +OBJECTIVE-C,Language syntax and basics|Object-oriented concepts|Memory management|Foundation framework|Cocoa Touch integration|Interface Builder usage|Debugging techniques|Performance optimization|Legacy code maintenance|Migration strategies +COMPUTER VISION,Image processing fundamentals|Feature detection and extraction|Object recognition|Deep learning for vision|OpenCV library usage|Image classification|Object tracking|Face recognition|Medical imaging|Real-time processing +XCODE,IDE navigation and features|Project organization|Interface Builder usage|Debugging tools|Performance profiling|Version control integration|Simulator usage|App Store submission|Build configurations|Testing frameworks +RUST,Memory safety concepts|Ownership and borrowing|Error handling|Pattern matching|Concurrency primitives|Cargo package manager|Testing strategies|Performance optimization|Unsafe Rust|WebAssembly integration +SYSTEM DESIGN,Scalability patterns|Load balancing strategies|Database design choices|Caching mechanisms|Microservices architecture|API design principles|Reliability and fault tolerance|Performance optimization|Security considerations|Monitoring and observability +TELEMETRY,Data collection strategies|Metrics and logging|Distributed tracing|Performance monitoring|Error tracking|Business intelligence|Privacy considerations|Data retention policies|Visualization techniques|Alert configuration +CLOUD COMPUTING,Service models and deployment|Cost optimization strategies|Security best practices|Multi-cloud strategies|Migration planning|Disaster recovery|Compliance requirements|Performance monitoring|Resource management|Vendor evaluation +DATA MANAGEMENT,Data governance frameworks|Data quality assurance|Master data management|Data lifecycle management|Privacy and compliance|Data integration strategies|Metadata management|Data security|Backup and recovery|Performance optimization +OPERATORS,Kubernetes operator patterns|Custom resource definitions|Controller implementation|Lifecycle management|Reconciliation loops|Testing strategies|Deployment patterns|Monitoring and observability|Security considerations|Best practices +MIGRATIONS,Database schema changes|Data migration strategies|Version control for databases|Rollback procedures|Zero-downtime deployments|Testing migrations|Performance considerations|Automation tools|Documentation practices|Risk mitigation +COMBINE,Reactive programming concepts|Publisher and Subscriber|Operators and transformations|Error handling|Backpressure management|Testing strategies|Performance optimization|Integration patterns|Debugging techniques|Best practices +AZURE DEVOPS,Project management setup|Source control integration|Build pipeline configuration|Release management|Testing integration|Artifact management|Security scanning|Reporting and analytics|Integration capabilities|Automation strategies +EDITORS,Text editor features|Code syntax highlighting|Plugin and extension systems|Customization options|Keyboard shortcuts|Version control integration|Debugging integration|Performance optimization|Collaboration features|Productivity tools +INFRASTRUCTURE AS CODE,IaC principles and benefits|Terraform fundamentals|CloudFormation usage|Ansible automation|Version control integration|Testing strategies|Security scanning|Cost optimization|Documentation practices|Team collaboration +PENETRATION TESTING,Testing methodologies|Reconnaissance techniques|Vulnerability assessment|Exploitation strategies|Post-exploitation activities|Reporting procedures|Legal and ethical considerations|Tool utilization|Risk assessment|Remediation guidance +CONTAINERIZATION,Container fundamentals|Image creation and management|Registry operations|Networking configurations|Storage solutions|Security hardening|Orchestration basics|Monitoring strategies|Performance optimization|Best practices +JAVASCRIPT,Language fundamentals|DOM manipulation|Async programming|ES6+ features|Error handling|Testing strategies|Performance optimization|Security considerations|Module systems|Debugging techniques +AI,Artificial intelligence concepts|Machine learning fundamentals|Deep learning basics|Natural language processing|Computer vision applications|AI ethics and bias|Model deployment|Performance optimization|Evaluation metrics|Continuous learning +REACT,Component architecture|State management|Props and context|Event handling|Lifecycle methods|Hooks usage|Performance optimization|Testing strategies|Build and deployment|Best practices +PYTHON,Language fundamentals|Data structures|Object-oriented programming|Functional programming|Error handling|File I/O operations|Libraries and frameworks|Testing strategies|Performance optimization|Package management +TYPESCRIPT,Type system fundamentals|Interface definitions|Generic programming|Decorator usage|Module systems|Compilation process|Debugging techniques|Integration strategies|Performance considerations|Best practices +SQL,Database query fundamentals|Join operations|Subqueries and CTEs|Indexing strategies|Performance optimization|Transaction management|Security considerations|Stored procedures|Data modeling|Query analysis +COMMUNICATION SKILLS,Verbal communication|Written communication|Active listening|Presentation skills|Conflict resolution|Cross-cultural communication|Digital communication|Feedback techniques|Meeting facilitation|Stakeholder engagement +DEBUGGING,Debugging methodologies|Tool utilization|Error analysis|Performance profiling|Memory analysis|Network debugging|Security debugging|Testing integration|Documentation practices|Problem-solving strategies +WEBPACK,Module bundling concepts|Configuration setup|Loader and plugin system|Code splitting strategies|Development server|Production optimization|Asset management|Source maps|Hot module replacement|Performance optimization +C++,Language fundamentals|Object-oriented programming|Memory management|Template programming|Standard Template Library|Concurrency and parallelism|Performance optimization|Debugging techniques|Build systems|Best practices +ACCESSIBILITY,Web accessibility standards|ARIA implementation|Screen reader compatibility|Keyboard navigation|Color and contrast|Testing methodologies|Legal compliance|User experience|Development practices|Continuous improvement +ANGULAR,Component architecture|Dependency injection|Reactive forms|Routing implementation|HTTP client usage|State management|Testing strategies|Performance optimization|Build and deployment|Best practices +OBSERVABILITY,Monitoring strategies|Logging practices|Distributed tracing|Metrics collection|Alerting systems|Dashboard creation|Performance analysis|Troubleshooting techniques|Tool integration|Continuous improvement +GRAPHQL,Schema design|Query language|Resolver implementation|Performance optimization|Caching strategies|Error handling|Testing approaches|Security considerations|Federation patterns|Tool ecosystem +RELATIONAL DATABASES,Database design principles|Normalization techniques|Query optimization|Index management|Transaction handling|Backup and recovery|Performance tuning|Security configuration|Replication setup|Monitoring strategies +AZURE,Service overview|Identity management|Virtual machines|Storage solutions|Networking configuration|Security features|Cost management|Monitoring tools|Automation capabilities|Best practices +REST API,API design principles|HTTP methods and status codes|Resource modeling|Authentication strategies|Error handling|Documentation practices|Versioning strategies|Testing approaches|Performance optimization|Security considerations +DATADOG,Monitoring setup|Dashboard creation|Alert configuration|Log management|APM integration|Infrastructure monitoring|Custom metrics|Integration capabilities|Cost optimization|Best practices +D3.JS,Data visualization concepts|Selection and manipulation|Scales and axes|Layouts and generators|Animation techniques|Interaction handling|Performance optimization|Testing strategies|Integration patterns|Best practices +NODE.JS,Runtime fundamentals|Module system|Asynchronous programming|Express framework|Database integration|Error handling|Testing strategies|Performance optimization|Security considerations|Deployment practices +POSTGRESQL,Database administration|Query optimization|Index management|Replication setup|Backup strategies|Performance tuning|Security configuration|Extension usage|Monitoring techniques|Troubleshooting +VITE,Build tool fundamentals|Development server|Plugin system|Asset handling|Production optimization|TypeScript integration|Framework support|Performance features|Configuration options|Migration strategies +NEXT.JS,React framework features|Server-side rendering|Static site generation|API routes|File-based routing|Image optimization|Performance optimization|Deployment strategies|Testing approaches|Best practices +TERRAFORM,Infrastructure as code|Provider configuration|Resource management|State management|Module development|Testing strategies|Security scanning|Team collaboration|Performance optimization|Best practices +SWIFT,Language fundamentals|Object-oriented programming|Protocol-oriented programming|Memory management|Concurrency features|Error handling|Testing strategies|Performance optimization|Interoperability|Best practices +VERSION CONTROL,Git fundamentals|Branching strategies|Merge and rebase|Conflict resolution|Remote repositories|Collaborative workflows|Release management|Security considerations|Tool integration|Best practices +CYPRESS,End-to-end testing|Test automation|Browser interaction|API testing|Visual testing|Debugging techniques|CI/CD integration|Performance considerations|Test organization|Best practices +OPERATING SYSTEMS,OS fundamentals|Process management|Memory management|File systems|I/O operations|Security features|Performance optimization|System administration|Troubleshooting techniques|Virtualization +ESLINT,Code linting setup|Rule configuration|Custom rule development|Integration strategies|Performance optimization|Error handling|Team collaboration|Continuous integration|Plugin ecosystem|Best practices +LINTING,Code quality standards|Static analysis|Rule configuration|Tool integration|Automation strategies|Performance considerations|Team adoption|Continuous improvement|Error handling|Best practices +SERVICE DESIGN,Design thinking principles|User journey mapping|Service blueprinting|Stakeholder analysis|Prototyping techniques|Testing methodologies|Implementation strategies|Continuous improvement|Measurement techniques|Team collaboration +PROJECT MANAGEMENT TOOLS,Tool selection criteria|Setup and configuration|Workflow design|Team collaboration|Progress tracking|Reporting capabilities|Integration strategies|Performance optimization|User training|Best practices +A/B TESTING,Experimental design|Hypothesis formation|Statistical significance|Sample size calculation|Test implementation|Data analysis|Decision making|Continuous testing|Tool selection|Best practices +METASPLOIT,Framework architecture|Module development|Exploit execution|Payload generation|Post-exploitation|Evasion techniques|Report generation|Integration strategies|Legal considerations|Defensive applications +BURP SUITE,Web application testing|Proxy configuration|Scanner usage|Intruder attacks|Repeater functionality|Extension development|Professional features|Automation strategies|Reporting capabilities|Integration techniques +OWASP,Security framework|Top 10 vulnerabilities|Testing methodologies|Security standards|Tool recommendations|Community resources|Training materials|Compliance guidance|Risk assessment|Best practices +.NET,Framework architecture|C# programming|ASP.NET development|Entity Framework|Dependency injection|Testing strategies|Performance optimization|Security considerations|Deployment practices|Best practices +THE FUNDAMENTALS,Core concept understanding|Foundation building|Basic principle application|Skill development|Knowledge integration|Practice methodologies|Assessment techniques|Continuous learning|Problem-solving|Critical thinking +PREFERENCES,User preference management|Configuration systems|Personalization features|Settings persistence|Default handling|Migration strategies|Performance considerations|Security aspects|User experience|Testing approaches +DEEP LEARNING,Neural network architectures|Training methodologies|Optimization techniques|Regularization strategies|Transfer learning|Model evaluation|Hardware acceleration|Framework usage|Deployment strategies|Research applications +TENSORFLOW,Framework fundamentals|Model building|Training procedures|Deployment strategies|Performance optimization|TensorBoard usage|Distributed training|Custom operations|Testing approaches|Production considerations +AIRFLOW,Workflow orchestration|DAG development|Task management|Scheduling strategies|Monitoring capabilities|Error handling|Scaling techniques|Integration patterns|Security considerations|Best practices +FINE-TUNING,Model adaptation|Transfer learning|Parameter optimization|Data preparation|Training strategies|Evaluation metrics|Performance monitoring|Resource management|Deployment considerations|Continuous improvement +NLP,Natural language processing|Text preprocessing|Tokenization techniques|Language models|Sentiment analysis|Named entity recognition|Machine translation|Information extraction|Evaluation metrics|Application development +LOOKER,Data platform setup|Model development|Dashboard creation|Visualization techniques|User management|Performance optimization|Integration capabilities|Security configuration|Collaboration features|Best practices +NOTIFICATIONS,Notification systems|Delivery mechanisms|User preferences|Content personalization|Performance optimization|Privacy considerations|Testing strategies|Analytics integration|Cross-platform support|Best practices +PANDAS,Data manipulation|DataFrame operations|Data cleaning|Statistical analysis|Visualization integration|Performance optimization|Memory management|File I/O operations|Testing strategies|Best practices +TRANSFORMERS,Architecture fundamentals|Attention mechanisms|Model training|Fine-tuning techniques|Inference optimization|Framework integration|Deployment strategies|Performance monitoring|Research applications|Best practices +NUMPY,Array operations|Mathematical functions|Broadcasting concepts|Performance optimization|Memory management|Integration patterns|Vectorization techniques|Linear algebra|Random number generation|Best practices +SCIKIT-LEARN,Machine learning algorithms|Model selection|Data preprocessing|Feature engineering|Cross-validation|Performance metrics|Pipeline construction|Model persistence|Integration strategies|Best practices +HUGGINGFACE,Model hub usage|Transformer implementations|Dataset management|Training workflows|Fine-tuning procedures|Deployment strategies|Performance optimization|Community contributions|Integration patterns|Best practices +INTENT,Intent recognition|Classification techniques|Training data preparation|Model development|Evaluation metrics|Integration strategies|Performance optimization|Error handling|Continuous improvement|User experience +FLUTTER,Cross-platform development|Widget architecture|State management|Navigation implementation|Platform integration|Performance optimization|Testing strategies|Deployment procedures|Plugin development|Best practices +CORE SERVICES,Service architecture|API design|Data management|Security implementation|Performance optimization|Monitoring strategies|Scalability planning|Integration patterns|Testing approaches|Documentation practices +CIRCLECI,CI/CD pipeline setup|Workflow configuration|Build optimization|Testing integration|Deployment automation|Monitoring capabilities|Security features|Performance optimization|Team collaboration|Best practices +KANBAN,Workflow visualization|Work-in-progress limits|Continuous flow|Metrics and analytics|Team collaboration|Process improvement|Tool integration|Performance monitoring|Stakeholder communication|Best practices +CREDENTIALS,Credential management|Security practices|Storage solutions|Rotation strategies|Access controls|Audit procedures|Integration patterns|Performance considerations|Compliance requirements|Best practices +HELM,Kubernetes package management|Chart development|Release management|Template functionality|Value configuration|Repository management|Security considerations|Testing strategies|Best practices|Troubleshooting \ No newline at end of file diff --git a/backend/Using/Task_Gen/data/missing_concepts.csv b/backend/Using/Task_Gen/data/missing_concepts.csv new file mode 100644 index 00000000..484e03b0 --- /dev/null +++ b/backend/Using/Task_Gen/data/missing_concepts.csv @@ -0,0 +1,50 @@ +concept +ACL +APT +AUTHENTICATION +Antimalware +Antivirus +Certificates +Containment +DATA PIPELINES +DJANGO +DLP +EAP vs PEAP +EDR +ELASTICSEARCH +Eradication +Firewall & Nextgen Firewall +HIPS +Host Based Firewall +Identification +Kerberos +Known vs Unknown +LDAP +LINUX +Lessons Learned +Local Auth +MACHINE LEARNING +MICROSERVICES +MYSQL +NIDS +NIPS +OAUTH +POSITIONING +POWER BI +Preparation +RADIUS +REDIS +Recovery +SSO +Sandboxing +Security Skills and Knowledge +TABLEAU +Understand Basics of Forensics +Understand Common Exploit Frameworks +Understand Common Hacking Tools +Understand Concept of Defense in Depth +Understand Concept of Runbooks +VirusTotal +WPA vs WPA2 vs WPA3 vs WEP +WPS +Zero Day diff --git a/backend/Using/Task_Gen/data/remaining_concepts.csv b/backend/Using/Task_Gen/data/remaining_concepts.csv new file mode 100644 index 00000000..0bafd25a --- /dev/null +++ b/backend/Using/Task_Gen/data/remaining_concepts.csv @@ -0,0 +1,385 @@ +concept +FTP / SFTP +DNS +HTTP +SSL / TLS +SSH +White / Grey Listing +SMTP +DMARC +IMAP +SPF +POP3S +Domain Keys +OSI Model +Networking & Protocols +Vercel +Cloudflare +Azure Functions +AWS Lambda +Netlify +Provisioning +OSCP +CREST +CISSP +MacOS +Installation and Configuration +Different Versions and Differences +Navigating using GUI and CLI +Understand Permissions +Installing Software and Applications +Performing CRUD on Files +Troubleshooting +Common Commands +Networking Knowledge +Understand the OSI Model +Common Protocols and their Uses +Common Ports and their Uses +SSL and TLS Basics +Basics of NAS and SAN +Basics of Subnetting +Public vs Private IP Addresses +localhost +loopback +CIDR +subnet mask +default gateway +VLAN +DMZ +ARP +VM +DHCP +NAT +IP +Router +Switch +VPN +MAN +LAN +WAN +WLAN +NTP +IPAM +Star +Ring +Mesh +Bus +RDP +FTP +SFTP +VMWare +VirtualBox +esxi +proxmox +Hypervisor +GuestOS +HostOS +nslookup +iptables +Packet Sniffers +ipconfig +netstat +Port Scanners +ping +dig +Protocol Analyzers +nmap +route +tcpdump +tracert +Kerberos +LDAP +SSO +RADIUS +Certificates +Local Auth +Security Skills and Knowledge +Understand Common Hacking Tools +Understand Common Exploit Frameworks +Understand Concept of Defense in Depth +Understand Concept of Runbooks +Understand Basics of Forensics +Basics and Concepts of Threat Hunting +Basics of Vulnerability Management +Basics of Reverse Engineering +Penetration Testing Rules of Engagement +Perimiter vs DMZ vs Segmentation +Core Concepts of Zero Trust +Roles of Compliance and Auditors +Understand the Definition of Risk +Understand Backups and Resiliency +Cyber Kill Chain +MFA & 2FA +Operating System Hardening +Understand Concept of Isolation +Basics of IDS and IPS +Honeypots +Authentication vs Authorization +Blue / Red / Purple Teams +False Negative / False Positive +True Negative / True Positive +"Basics of Threat Intel, OSINT" +Understand Handshakes +Understand CIA Triad +Privilege Escalation +Web Based Attacks and OWASP10 +Learn how Malware works and Types +curl +hping +cat +dd +head +grep +wireshark +winhex +memdump +FTK Imager +autopsy +tail +Salting +Hashing +Key Exchange +PKI +Private vs Public Keys +Obfuscation +ATT&CK +Kill Chain +Diamond Model +ISO +RMF +CIS +CSF +SIEM +SOAR +ParrotOS +Kali Linux +LOLBAS +Event Logs +syslogs +netflow +Packet Captures +Firewall Logs +MAC-based +NAC-based +Port Blocking +Group Policy +ACLs +Sinkholes +Patching +Jump Server +Endpoint Security +FTP vs SFTP +SSL vs TLS +IPSEC +DNSSEC +LDAPS +SRTP +S/MIME +Antivirus +Antimalware +EDR +DLP +ACL +Firewall & Nextgen Firewall +HIPS +NIDS +NIPS +Host Based Firewall +Sandboxing +EAP vs PEAP +WPS +WPA vs WPA2 vs WPA3 vs WEP +Preparation +Identification +Containment +Eradication +Recovery +Lessons Learned +Zero Day +Known vs Unknown +APT +VirusTotal +Joe Sandbox +any.run +urlvoid +urlscan +WHOIS +Phishing +Whishing +Whaling +Smishing +Spam vs Spim +Shoulder Surfing +Dumpster Diving +Tailgating +Social Engineering +Reconnaissance +Impersonation +Watering Hole Attack +Drive by Attack +Typo Squatting +Brute Force vs Password Spray +DoS vs DDoS +MITM +Spoofing +Evil Twin +DNS Poisoning +Deauth Attack +VLAN Hopping +Rogue Access Point +Buffer Overflow +Memory Leak +XSS +SQL Injection +CSRF +Replay Attack +Pass the Hash +Directory Traversal +Stakeholders +HR +Legal +Compliance +Management +Cloud Skills and Knowledge +Understand the Concept of Security in the Cloud +Understand the basics and general flow of deploying in the cloud +Understand the differences between cloud and on-premises +Understand the concept of Infrastructure as Code +Understand the Concept of Serverless +SaaS +PaaS +IaaS +Private +Public +Hybrid +GCP +Dropbox +Box +OneDrive +Google Drive +GTFOBINS +WADCOMS +ORACLE +TRANSACTIONS +DATA-DRIVEN DECISION MAKING +AGILE +CONFLUENCE +DOCKER +EMOTIONAL INTELLIGENCE +JENKINS +JIRA +KUBERNETES +PERFORMANCE METRICS +SCRUM +SPLUNK +STRATEGIC THINKING +PROGRAMMING SKILLS +STATISTICS +DISTRIBUTED SYSTEMS +ORCHESTRATION +FLINK +KAFKA +SCALA +GENERATIVE AI +CASSANDRA +NOSQL DATABASES +NETWORKING +SPARK +DATA STRUCTURES AND ALGORITHMS +ELASTICSEARCH +REDIS +DATA PIPELINES +MYSQL +POSITIONING +POWER BI +TABLEAU +AUTHENTICATION +LINUX +MICROSERVICES +MACHINE LEARNING +OAUTH +DJANGO +FASTAPI +FLASK +MLOPS +PYTORCH +REACT NATIVE +MATHEMATICS +ANDROID +ERROR HANDLING +JAVA +UNIT TESTING +OBJECTIVE-C +COMPUTER VISION +XCODE +RUST +SYSTEM DESIGN +TELEMETRY +CLOUD COMPUTING +DATA MANAGEMENT +OPERATORS +MIGRATIONS +COMBINE +AZURE DEVOPS +EDITORS +INFRASTRUCTURE AS CODE +PENETRATION TESTING +CONTAINERIZATION +JAVASCRIPT +AI +REACT +PYTHON +TYPESCRIPT +SQL +COMMUNICATION SKILLS +DEBUGGING +WEBPACK +C++ +ACCESSIBILITY +ANGULAR +OBSERVABILITY +GRAPHQL +RELATIONAL DATABASES +AZURE +REST API +DATADOG +D3.JS +NODE.JS +POSTGRESQL +VITE +NEXT.JS +TERRAFORM +SWIFT +VERSION CONTROL +CYPRESS +OPERATING SYSTEMS +ESLINT +LINTING +SERVICE DESIGN +PROJECT MANAGEMENT TOOLS +A/B TESTING +METASPLOIT +BURP SUITE +OWASP +.NET +THE FUNDAMENTALS +PREFERENCES +DEEP LEARNING +TENSORFLOW +AIRFLOW +FINE-TUNING +NLP +LOOKER +NOTIFICATIONS +PANDAS +TRANSFORMERS +NUMPY +SCIKIT-LEARN +HUGGINGFACE +INTENT +FLUTTER +CORE SERVICES +CIRCLECI +KANBAN +CREDENTIALS +HELM diff --git a/backend/Using/Task_Gen/data/subtopics.csv b/backend/Using/Task_Gen/data/subtopics.csv new file mode 100644 index 00000000..bae0ad27 --- /dev/null +++ b/backend/Using/Task_Gen/data/subtopics.csv @@ -0,0 +1,1125 @@ +concept,subtopics +SOAP,"Introduction to Web Services and XML|SOAP Message Structure and Envelope|WSDL (Web Services Description Language)|SOAP Bindings and Protocols (HTTP, SMTP)|SOAP Faults and Error Handling|SOAP vs REST Comparison|Implementing SOAP Clients and Servers" +CI/CD,"Introduction to Continuous Integration Principles|Version Control Systems (Git) for CI/CD|Automated Build Processes|Unit and Integration Testing in CI|Continuous Delivery vs Continuous Deployment|Deployment Strategies (Blue/Green, Canary)|CI/CD Pipeline Tools (e.g., Jenkins, GitLab CI, GitHub Actions)|Infrastructure as Code for CI/CD|Monitoring and Feedback Loops in CD" +Vim / Nano / Emacs,"Basic Text Editing with Nano|Vim Modes (Normal, Insert, Visual, Command)|Vim Basic Navigation and Editing Commands|Vim Search, Replace, and Undo/Redo|Vim Configuration (.vimrc) and Plugins|Emacs Basic Navigation and Editing|Emacs Buffers, Windows, and Frames|Emacs Lisp for Customization" +DOM Manipulation,"Understanding the Document Object Model Tree Structure|Selecting Elements (getElementById, querySelector)|Modifying Element Content (textContent, innerHTML)|Changing Element Attributes and Styles|Creating and Appending New Elements|Event Handling and Listeners|Traversing the DOM (Parent, Child, Sibling Nodes)|Performance Considerations for DOM Manipulation" +Advanced JavaScript Concepts,"Closures and Scope Chains|Prototypal Inheritance and Object Prototypes|The 'this' Keyword Context Binding|Asynchronous JavaScript (Promises, Async/Await)|Generators and Iterators|Decorators and Proxies|Module Systems (CommonJS, ES Modules)|Error Handling and Custom Errors" +Frontend Framework Fundamentals,"Introduction to Component-Based Architecture|Data Binding and State Management Basics|Routing and Navigation within SPAs|Lifecycle Hooks of Components|Event Handling and User Interaction|Templating Syntax (JSX, Vue Templates, Angular Templates)|Build Tools and Project Setup (Webpack, Vite)|Performance Optimization Techniques" +Cloud Services Architecture,"Cloud Computing Models (IaaS, PaaS, SaaS)|Deployment Models (Public, Private, Hybrid)|Core Cloud Services (Compute, Storage, Networking)|Serverless Computing Concepts|Microservices Architecture in the Cloud|Containerization and Orchestration (Kubernetes)|Cloud Security Best Practices|Cost Management and Optimization in the Cloud" +Infrastructure Concepts,"Operating System Fundamentals (Linux, Windows)|Networking Basics (TCP/IP, DNS, HTTP)|Virtualization Technologies (VMs, Hypervisors)|Storage Systems (SAN, NAS, Object Storage)|Databases (Relational vs NoSQL)|Load Balancing and High Availability|Monitoring and Logging Systems|Infrastructure as Code (Terraform, Ansible)" +Cloud Provider Ecosystems,"Introduction to Major Cloud Providers (AWS, Azure, GCP)|Core Compute Services (EC2, Azure VMs, GCE)|Core Storage Services (S3, Azure Blob, GCS)|Core Networking Services (VPC, VNet, GCP VPC)|Database Services (RDS, Azure SQL, Cloud SQL)|Serverless Offerings (Lambda, Azure Functions, Cloud Functions)|Managed Kubernetes Services (EKS, AKS, GKE)|Identity and Access Management (IAM) across providers" +Data Architecture Patterns,"Relational Database Design Principles|NoSQL Database Types and Use Cases|Data Warehousing and Data Lakes|ETL/ELT Processes|Batch Processing vs Stream Processing|Data Governance and Data Quality|Data Modeling Techniques (Dimensional, ER)|Data Security and Privacy Considerations" +Advanced Data Infrastructure,"Distributed Database Systems (Sharding, Replication)|Big Data Technologies (Hadoop, Spark)|Data Streaming Platforms (Kafka, Kinesis)|Columnar Databases and OLAP Systems|Graph Databases and Their Applications|Data Mesh and Data Fabric Concepts|Data Observability and Monitoring|Data Pipeline Orchestration (Airflow, Dagster)" +Cryptography Fundamentals,"Basic Cryptographic Terminology (Cipher, Plaintext, Ciphertext)|Symmetric-Key Cryptography (AES, DES)|Asymmetric-Key Cryptography (RSA, ECC)|Hashing Functions and Digital Signatures|Key Exchange Protocols (Diffie-Hellman)|Public Key Infrastructure (PKI) and Certificates|Random Number Generation for Cryptography|Common Cryptographic Attacks and Countermeasures" +Secrets Management,"Understanding the Need for Secrets Management|Hardcoding vs Environment Variables for Secrets|Secrets Sprawl and its Risks|Key Management Systems (KMS) Concepts|Vaulting Solutions (HashiCorp Vault, AWS Secrets Manager)|Integrating Secrets Management with CI/CD|Rotation and Lifecycle Management of Secrets|Auditing and Monitoring Secret Access" +Network Security Concepts,"Firewalls and Intrusion Detection/Prevention Systems (IDS/IPS)|Virtual Private Networks (VPNs)|Network Segmentation and VLANs|Denial of Service (DoS) and Distributed DoS (DDoS) Attacks|Packet Sniffing and Man-in-the-Middle Attacks|Authentication, Authorization, and Accounting (AAA)|Wireless Network Security (WPA2/3)|Security Information and Event Management (SIEM)" +Security Tools Fundamentals,"Vulnerability Scanners (Nessus, OpenVAS)|Penetration Testing Tools (Metasploit, Nmap)|Static Application Security Testing (SAST)|Dynamic Application Security Testing (DAST)|Security Information and Event Management (SIEM) Platforms|Endpoint Detection and Response (EDR) Solutions|Web Application Firewalls (WAFs)|Identity and Access Management (IAM) Systems" +Supervised vs Unsupervised Learning,"Introduction to Machine Learning Paradigms|Labeled vs Unlabeled Data|Regression Algorithms (Linear, Polynomial)|Classification Algorithms (Logistic Regression, SVM, Decision Trees)|Clustering Algorithms (K-Means, Hierarchical)|Dimensionality Reduction Techniques (PCA)|Evaluation Metrics for Supervised Learning|Evaluation Metrics for Unsupervised Learning" +Neural Networks,"Biological Neuron Analogy and Perceptrons|Activation Functions (Sigmoid, ReLU, Tanh)|Feedforward Neural Networks Architecture|Backpropagation Algorithm for Training|Loss Functions and Optimizers (SGD, Adam)|Overfitting and Regularization Techniques|Convolutional Neural Networks (CNNs) Basics|Recurrent Neural Networks (RNNs) Basics" +Advanced Deep Learning,"Advanced CNN Architectures (ResNet, Inception)|Object Detection and Segmentation (YOLO, Mask R-CNN)|Advanced RNNs (LSTMs, GRUs)|Attention Mechanisms and Transformers|Generative Adversarial Networks (GANs)|Reinforcement Learning Fundamentals|Transfer Learning and Fine-tuning Models|Model Deployment and MLOps for Deep Learning" +Product Management Fundamentals,Defining Product Vision and Strategy|Understanding User Needs and Market Research|Product Lifecycle Management|Agile Methodologies for Product Development|Roadmapping and Prioritization Techniques|Metrics and KPIs for Product Success|Stakeholder Management and Communication|Go-to-Market Strategy Basics +Strategic Product Planning,Market Analysis and Competitive Landscape|Business Model Innovation and Value Proposition Design|Long-Term Product Vision and North Star Metrics|Portfolio Management and Product Line Strategy|Disruptive Innovation and Technology Trends|Strategic Partnerships and Ecosystem Development|Financial Modeling for Product Investment|Organizational Alignment for Product Strategy +Product Analytics Framework,Understanding Product Analytics Goals|Key Metrics and KPIs Definition|Event Tracking and Data Collection Strategies|Funnel Analysis and User Journey Mapping|Segmentation and Cohort Analysis|A/B Testing and Experimentation Frameworks|North Star Metric Identification and Alignment +Metrics Design & Analysis,Defining Business Objectives and Key Results|Types of Metrics: Vanity vs. Actionable|Metric Hierarchies and Relationships|Data Sources and Collection Methods for Metrics|Statistical Significance and Hypothesis Testing|Anomaly Detection and Trend Analysis|Dashboard Design and Reporting Best Practices +Web Storage,"Introduction to Client-Side Storage|Cookies: Purpose, Limitations, and Management|localStorage and sessionStorage APIs|IndexedDB for Structured Data Storage|Web SQL Database (Historical Context)|Security Considerations for Web Storage|Performance Implications of Client-Side Storage" +Mobile Storage,Overview of Mobile Storage Options|Shared Preferences (Android) / UserDefaults (iOS)|File System Storage and Access Permissions|SQLite Database for Structured Data|Core Data Framework (iOS) for Object Persistence|Room Persistence Library (Android) for SQLite Abstraction|Secure Storage Best Practices on Mobile +NIST,Introduction to NIST and its Mission|NIST Cybersecurity Framework Overview|NIST Special Publications (SP 800 Series)|NIST Risk Management Framework (RMF)|NIST Cryptographic Standards and Guidelines|Compliance with NIST Standards|Implementing NIST Controls in Organizations +AWS,AWS Global Infrastructure and Regions|Identity and Access Management (IAM) Fundamentals|Amazon EC2: Virtual Servers in the Cloud|Amazon S3: Object Storage Service|Amazon VPC: Virtual Private Cloud Networking|AWS Lambda: Serverless Compute|Amazon RDS: Managed Relational Databases|CloudFormation for Infrastructure as Code|Cost Optimization and Billing Management +Econometrics,"Introduction to Econometrics and its Scope|Basic Statistical Concepts and Probability|Simple Linear Regression (OLS)|Multiple Linear Regression Assumptions and Estimation|Hypothesis Testing and Confidence Intervals|Addressing Violations of OLS Assumptions (e.g., Heteroskedasticity)|Time Series Analysis Fundamentals|Panel Data Models and Fixed/Random Effects|Instrumental Variables and Causality" +Coding,"Basic Syntax, Variables, and Data Types|Control Flow: Conditionals and Loops|Functions and Modular Programming|Fundamental Data Structures (Arrays, Lists, Dictionaries)|Object-Oriented Programming Concepts|Algorithms and Problem-Solving Techniques|Debugging and Error Handling|Version Control with Git|Unit Testing and Test-Driven Development" +Exploratory Data Analysis,"Understanding Data Types and Structures|Summary Statistics and Descriptive Analysis|Data Cleaning and Preprocessing Techniques|Univariate Data Visualization (Histograms, Box Plots)|Bivariate and Multivariate Data Visualization (Scatter Plots, Heatmaps)|Outlier Detection and Treatment|Missing Data Imputation Strategies|Correlation Analysis and Feature Relationships|Hypothesis Generation from Data Insights" +Swift (Recommended),"Swift Basic Syntax, Variables, and Constants|Data Types, Type Inference, and Type Safety|Control Flow: Conditionals and Loops|Functions, Closures, and Optionals|Structs, Classes, and Enums|Protocols and Protocol-Oriented Programming|Error Handling and Generics|Memory Management with ARC|Concurrency with async/await" +History and Why Swift?,"Objective-C's Legacy and Limitations|Apple's Motivation for Creating Swift|Key Design Goals of Swift (Safety, Performance, Modernity)|Evolution of Swift Versions and Features|Impact of Swift on iOS/macOS Development|Swift's Open Source Journey and Community|Future Directions and Vision for Swift" +Benefits over Objective-C,Simplified and Modern Syntax|Enhanced Type Safety and Optionals for Nil Handling|Automatic Reference Counting (ARC) for Memory Management|Value Types with Structs and Enums|Protocol-Oriented Programming Paradigm|Improved Performance and Compiler Optimizations|Better Error Handling Mechanisms +Interoperability with Swift,Calling Objective-C Code from Swift|Calling Swift Code from Objective-C|Using Bridging Headers for Mixed Projects|Module Stability and Binary Compatibility|Interacting with C and C++ Libraries|Best Practices for Mixed-Language Projects|Debugging Mixed Swift and Objective-C Code +iOS Architecture,"Overview of the iOS Software Layers|Model-View-Controller (MVC) Design Pattern|Application Lifecycle and States|Delegation and Notification Patterns|Grand Central Dispatch (GCD) for Concurrency|Memory Management and ARC in iOS|Introduction to Other Design Patterns (MVVM, VIPER)|Modularization and Dependency Injection" +Core OS,Understanding the iOS Kernel and Drivers|Process and Thread Management|Memory Management and Virtual Memory|File System and Data Persistence|Security Architecture and Sandboxing|Inter-Process Communication (IPC)|Low-Level System Calls and APIs +Media,"Introduction to Media Types (Audio, Video, Images)|Basic Audio Playback with AVAudioPlayer|Basic Video Playback with AVPlayer|Media Capture from Camera and Microphone|Media Editing and Manipulation Basics|Supported Media Formats and Codecs|Streaming Media Protocols and Technologies" +Core Graphics,"Introduction to Core Graphics Contexts|Basic Drawing Primitives (Lines, Rectangles, Circles)|Paths and Shapes Creation|Colors, Gradients, and Patterns|Transformations (Translation, Rotation, Scaling)|Image Manipulation and Contexts|Custom View Drawing with Core Graphics|Understanding Quartz 2D API" +Core Animation,Introduction to CALayer and Layer Hierarchy|Implicit Animations and Layer Properties|Explicit Animations with CABasicAnimation|Keyframe Animations with CAKeyframeAnimation|Animation Groups and Transitions|Timing Functions and Animation Curves|Custom Layer Properties and Animatable Values|Physics-Based Animations with UIKit Dynamics +AVFoundation,Playing Audio with AVAudioPlayer|Playing Video with AVPlayer and AVPlayerLayer|Capturing Audio and Video with AVCaptureSession|Working with Media Assets (AVAsset)|Custom Video Processing and Filters|Audio Mixing and Effects|Media Composition with AVMutableComposition|Real-time Audio and Video Processing +Core Image,Introduction to Core Image Filters|Applying Built-in Core Image Filters|Chaining Multiple Filters Together|Understanding CIImage and CIContext|Customizing Filter Parameters|Performance Optimization with Core Image|Creating Custom CIFilters with Kernel Programming|GPU Acceleration and Image Processing Pipelines +Core Audio,Introduction to Core Audio Framework|Audio Sessions and Categories|Audio Units (AUs) and their Types|Audio Recording and Playback|Audio Processing Graphs|Low-Latency Audio Techniques|MIDI Integration with Core Audio +Metal,Introduction to GPU Programming and Metal|Metal Device and Command Queue|Render Pipelines and Shaders (MSL)|Buffers and Textures|Drawing Primitives and Render Passes|Compute Pipelines and Kernels|Advanced Rendering Techniques|Performance Optimization in Metal +Cocoa Touch,"Introduction to iOS App Architecture (MVC)|UIKit Framework Overview|Views, Layers, and the View Hierarchy|User Interaction and Event Handling|Table Views and Collection Views|Navigation Controllers and Tab Bar Controllers|Data Persistence (User Defaults, Core Data)|Auto Layout and Adaptive UI" +Core Programming Concepts,"Variables, Data Types, and Operators|Control Flow (Conditionals, Loops)|Functions and Procedures|Basic Data Structures (Arrays, Lists, Dictionaries)|Algorithms (Sorting, Searching Basics)|Error Handling and Debugging|Input/Output Operations" +OOP,Objects and Classes|Encapsulation and Data Hiding|Inheritance and Polymorphism|Abstraction and Interfaces/Protocols|Constructors and Destructors|Design Principles (SOLID)|Common Design Patterns +Functional Programming,"Pure Functions and Immutability|First-Class and Higher-Order Functions|Lambda Expressions and Closures|Map, Filter, Reduce Operations|Recursion vs. Iteration|Function Composition and Pipelining|Side Effects and Referential Transparency" +Memory Management,"Stack vs. Heap Memory|Manual Memory Management Concepts|Automatic Reference Counting (ARC)|Strong, Weak, and Unowned References|Memory Leaks and Retain Cycles|Memory Profiling Tools|Value Types vs. Reference Types" +ViewController Lifecycle,"Introduction to UIViewController|Initialization and View Loading (viewDidLoad, loadView)|View Appearance and Disappearance (viewWillAppear, viewDidAppear)|View Layout and Updates (viewWillLayoutSubviews, viewDidLayoutSubviews)|Memory Warnings and Deallocation (deinit)|Container View Controllers|Responding to Device Rotations and Trait Changes" +"Concurrency (GCD, async/await)",Introduction to Concurrency and Parallelism|Threads and Processes|Grand Central Dispatch (GCD) Queues|DispatchWorkItem and DispatchGroup|Semaphores and Locks for Synchronization|Operation Queues and Operations|async/await for Structured Concurrency|Task Groups and Actors +Pick a Language,Understanding Programming Paradigms|Evaluating Language Features and Syntax|Community Support and Ecosystem|Performance Characteristics|Use Cases and Industry Demand|Learning Curve and Available Resources|Tooling and IDE Support +Git,"Version Control System Basics|Initializing a Git Repository|Staging and Committing Changes|Viewing History and Differences|Branching and Merging Fundamentals|Resolving Merge Conflicts|Undoing Changes (reset, revert)|Remote Repositories and Pushing/Pulling" +GitHub,Introduction to GitHub Platform|Creating and Managing Repositories|Cloning and Forking Repositories|Pull Requests and Code Reviews|Issues and Project Management|GitHub Actions for CI/CD|Collaborating with Teams +Installing,"Choosing an Operating System for Development|Installing a Text Editor or IDE|Setting Up a Programming Language Environment|Package Managers (e.g., Homebrew, npm, pip)|Environment Variables Configuration|Command Line Tools Installation|Verifying Installation and Basic Setup" +New Project,Understanding Project Templates|Creating a New Project in an IDE|Project Structure and File Organization|Configuring Project Settings|Adding Dependencies and Frameworks|Initial Code Setup and Entry Point|Running the Project on a Simulator/Device +Interface overview,"Main Window Layout and Panes|Editor Area and Code Navigation|Utility Area (Inspectors, Libraries)|Debug Area and Console Output|Toolbar and Common Actions|Status Bar and Notifications|Customizing the Interface Layout" +Toolbar,"Understanding Toolbar Buttons and Icons|Run/Stop Buttons and Scheme Selection|Device/Simulator Selection|Navigators, Debug, and Utilities Toggles|Editor Layout Options|Source Control Actions|Customizing the Toolbar" +Navigators,"Project Navigator (File Structure)|Source Control Navigator (Git Integration)|Symbol Navigator (Code Structure)|Find Navigator (Search and Replace)|Issue Navigator (Errors, Warnings)|Test Navigator (Unit and UI Tests)|Debug Navigator (Breakpoints, Variables)|Report Navigator (Build Logs, Test Results)" +Project Files,"Understanding File Types (e.g., .swift, .xib, .storyboard)|Info.plist and Project Configuration|AppDelegate and SceneDelegate Roles|Asset Catalogs for Images and Colors|Localizable Strings and Internationalization|Managing Resources (e.g., Fonts, Sounds)|Target Membership and Build Phases" +Groups,Purpose of Groups in Project Navigator|Creating and Organizing Groups|Understanding Group vs. Folder on Disk|Moving and Renaming Groups|Best Practices for Grouping Files|Impact on Project Structure and Navigation|Using Groups for Modularity +Breakpoints,"Introduction to Debugging and Breakpoints|Setting and Disabling Breakpoints|Conditional Breakpoints|Exception Breakpoints|Symbolic Breakpoints|Actions and Sounds with Breakpoints|Viewing Variables and Call Stack at Breakpoint|Stepping Through Code (Step Over, Step Into, Step Out)" +Debug Navigator,Introduction to Xcode Debugging Tools|Understanding the Debug Navigator Pane|Viewing Call Stacks and Threads|Inspecting Variables and Memory Addresses|Using Breakpoints Effectively|Conditional Breakpoints and Exception Breakpoints|Debugging with LLDB Commands +Stepping,Introduction to Code Execution Flow|Step Over (next) Command|Step Into (step) Command|Step Out (finish) Command|Continue Execution|Setting and Managing Breakpoints for Stepping|Debugging Asynchronous Code with Stepping +Interface Builder,Introduction to Xcode Interface Builder|Adding UI Elements to a Canvas|Configuring Element Attributes in the Attributes Inspector|Connecting UI Elements to Code (IBOutlets/IBActions)|Using the Document Outline|Previewing UI on Different Devices|Resolving Auto Layout Issues in Interface Builder +IBOutlets,Purpose of IBOutlets in iOS Development|Connecting UI Elements to Code with IBOutlets|Declaring IBOutlet Properties in Swift|Accessing and Modifying IBOutlet Properties Programmatically|Understanding the 'weak' Keyword for IBOutlets|Troubleshooting Broken IBOutlet Connections +IBActions,"Purpose of IBActions for User Interaction|Connecting UI Events to Code with IBActions|Declaring IBAction Methods in Swift|Handling Different Control Events (e.g., touchUpInside)|Passing Sender Information to IBAction Methods|Troubleshooting Broken IBAction Connections" +Auto layout,Introduction to Responsive UI Design|Understanding Constraints and Layout Anchors|Applying Constraints in Interface Builder|Programmatic Auto Layout with NSLayoutConstraint|Using Visual Format Language (VFL)|Debugging Auto Layout Conflicts|Adaptive Layout for Different Device Sizes and Orientations +UIKit,"Introduction to the UIKit Framework|Core Components of UIKit (Views, Controls, View Controllers)|Understanding the Responder Chain|Event Handling in UIKit|Common UIKit Controls (Buttons, Labels, Text Fields)|Working with Table Views and Collection Views|Customizing UIKit Components" +Components,Understanding UI Components in Software Design|Standard UIKit Components Overview|Customizing Existing UI Components|Creating Reusable Custom UI Components|Component Lifecycle Management|Designing for Component Reusability and Modularity|Component-Based Architecture Principles +Views,"Introduction to UIView and its Role|View Hierarchy and Subviews|Drawing Custom Content in a View (draw(rect:))|Handling View Layout and Resizing|View Transformations (Rotation, Scaling, Translation)|Animating View Properties|Performance Considerations for Complex View Hierarchies" +View Controllers,"Introduction to UIViewController|View Controller Lifecycle Methods (viewDidLoad, viewWillAppear, etc.)|Managing a View Hierarchy with a View Controller|Presenting and Dismissing View Controllers|Container View Controllers (Navigation, Tab Bar, Split View)|Communication Between View Controllers|Memory Management in View Controllers" +User Interactions,"Understanding Touch Events and Gestures|Implementing Tap Gestures|Implementing Pan, Pinch, and Rotate Gestures|Handling Button Taps and Control Events|Responding to Keyboard Input|Accessibility for User Interactions|Customizing Gesture Recognizers" +Basic Interfaces,"Designing Simple UI Layouts|Adding Labels, Buttons, and Images|Arranging Elements with Stack Views|Setting Colors, Fonts, and Backgrounds|Connecting UI to Basic Logic (IBOutlets/IBActions)|Displaying Alerts and Action Sheets|Building a Single-Screen Application" +Storyboards,Introduction to Storyboards for UI Design|Adding Scenes and View Controllers to a Storyboard|Creating Segues for Navigation|Passing Data Between View Controllers with Segues|Using Storyboard References|Resolving Merge Conflicts in Storyboards|Modularizing Storyboards +Xibs,Introduction to XIB Files (NIBs)|Designing Individual Views or View Controllers in XIBs|Loading XIBs Programmatically|Connecting XIB Elements to Code|Advantages and Disadvantages of XIBs vs. Storyboards|Using XIBs for Custom Table View Cells or Collection View Cells|Managing Multiple XIBs in a Project +Navigation,Understanding Navigation Patterns in iOS|Using UINavigationController for Hierarchical Navigation|Pushing and Popping View Controllers|Implementing Tab Bar Navigation with UITabBarController|Presenting Modal View Controllers|Customizing Navigation Bars and Tab Bars|Deep Linking and Universal Links +View Transitions,Understanding Standard View Controller Transitions|Customizing Modal Presentation Styles|Implementing Custom View Controller Transitions|Using UIViewControllerAnimatedTransitioning Protocol|Interactive Transitions with UIPercentDrivenInteractiveTransition|Animating Changes within a Single View (UIView.animate)|Transitioning Between Different States of a View +SwiftUI,"Introduction to Declarative UI with SwiftUI|Basic SwiftUI Views (Text, Image, Button)|Layout Containers (VStack, HStack, ZStack)|Modifiers for Customizing Views|State Management with @State and @Binding|Lists and Navigation in SwiftUI|Integrating SwiftUI with UIKit (and vice-versa)" +Declarative Syntax,"Understanding Declarative vs. Imperative Programming|Core Principles of Declarative UI|Applying Modifiers and View Composition|Data Flow in Declarative UI Frameworks|Advantages of Declarative Syntax (Readability, Predictability)|Common Patterns in Declarative UI (e.g., View Builders)|Comparing Declarative UI (SwiftUI, React) with Imperative UI (UIKit)" +State Management,"Understanding Application State|Local State with @State (SwiftUI) or useState (React)|Passing State with @Binding (SwiftUI) or Props (React)|Observable Objects and @ObservedObject / @StateObject (SwiftUI)|Environment Objects and @EnvironmentObject (SwiftUI)|Introduction to Global State Management Solutions (e.g., Redux, Combine, TCA)|Managing Side Effects in State Management" +Data binding,"Introduction to Data Binding Concepts|One-Way Data Binding|Two-Way Data Binding|Data Binding in SwiftUI (@State, @Binding, @ObservedObject)|Connecting UI Elements to Data Sources|Understanding Property Wrappers for Data Binding|Observing Data Changes and UI Updates" +Building Interfaces,"UI/UX Principles and Best Practices|Layout Systems (e.g., Auto Layout, Flexbox, Grid)|Component-Based Architecture|Event Handling and User Interaction|Data Binding and State Management|Accessibility Considerations in UI|Responsive and Adaptive Design" +Views and Modifiers,"Basic View Types (Text, Image, Button)|View Hierarchy and Composition|Common View Modifiers (padding, font, foregroundColor)|Layout Modifiers (frame, alignment, spacing)|Conditional View Modifiers|Custom View Modifiers|Environment Values and Modifiers" +UI Design,"User-Centered Design Principles|Information Architecture and User Flows|Wireframing and Prototyping Tools|Visual Design Principles (Color, Typography, Iconography)|Usability Testing and Feedback Integration|Accessibility in UI Design|Introduction to Design Systems" +HIG,"Purpose and Importance of Human Interface Guidelines|Core Principles (Clarity, Deference, Depth)|Platform-Specific Guidelines (iOS, macOS, watchOS, tvOS)|Standard UI Elements and Behaviors|Accessibility Guidelines in HIG|Adapting HIG for Custom Experiences" +"Views, View Controllers","UIViewController Lifecycle Methods|UIView Hierarchy and Subviews|Initializing Views Programmatically vs. Storyboards/NIBs|Auto Layout Constraints and Layout Anchors|Event Handling with Target-Action|Data Display with UILabel, UIImageView, etc.|Custom UIViews and Controls" +"Navigation Controllers, Segues","UINavigationController Stack Management|Pushing and Popping View Controllers|Storyboard Segues (Show, Present Modally, Popover)|Programmatic Segues and Data Passing|UINavigationBar Customization|Custom Transition Animations for Segues" +Navigation Stacks,Stack Data Structure Basics (LIFO)|Pushing and Popping Operations in Navigation|Root View Controller and Navigation History|Managing Navigation State|Deep Linking and Stack Restoration|Programmatic Control of Navigation Stacks +Pushing Presenting,Differentiating Push vs. Present Modally|When to Use Each Navigation Style|Animation Types for Push and Present|Dismissing Presented View Controllers|Custom Transition Animations for Presentation|Handling Navigation Delegates +Modals and Navigation,"Purpose and Use Cases for Modal Presentations|Full Screen vs. Page Sheet Modals|Presenting Modally Programmatically|Dismissing Modals and Completion Handlers|Data Flow with Modals (Delegation, Callbacks)|Modal Presentation Styles and Customization" +Navigation View,Basic NavigationView Usage in SwiftUI|Embedding Views in NavigationView|NavigationBarTitle and DisplayMode|NavigationBarItems and Toolbar|Programmatic Navigation with isActive|Customizing Navigation Bar Appearance +NavigationLink,Basic NavigationLink Usage and Destination Views|Passing Data with NavigationLink|isActive Binding for Programmatic Navigation|Styling NavigationLink|Conditional Navigation with NavigationLink|Integrating with NavigationStack (iOS 16+) +Presenting / Dismissing views,UIKit: present(_:animated:completion:)|UIKit: dismiss(animated:completion:)|SwiftUI: @Environment(\.presentationMode)|SwiftUI: @Binding for Sheet/Modal Presentation|Custom Presentation Modifiers|Handling Completion Callbacks for Presentation +Basics / Creating Animations,"Core Animation Principles (Timing, Easing, Interpolation)|Implicit vs. Explicit Animations|Keyframe Animations|UIKit: UIView.animate and Options|SwiftUI: withAnimation and Animation Modifiers|Animatable Modifiers and Custom Transitions" +Lottie,"Introduction to Lottie and JSON Animations|Integrating Lottie into iOS/Android/Web Projects|Playing Lottie Animations|Controlling Animation Progress and Speed|Looping and Reversing Animations|Interacting with Lottie Animations (Gestures, Markers)" +MVC,"Core Components: Model, View, Controller|Responsibilities of Each Component|Communication Patterns (Target-Action, Delegation)|Advantages and Disadvantages of MVC|MVC in UIKit Applications|Refactoring Massive View Controllers" +MVP,"Core Components: Model, View, Presenter|Passive View vs. Supervising Controller|Presenter's Role in Logic and View Updates|Communication Between Components|Testability of MVP Components|Comparing MVP to MVC" +MVVM,"Core Components: Model, View, ViewModel|Data Binding and Observables|ViewModel's Role in Exposing Data and Commands|Separation of Concerns in MVVM|Testability of ViewModels|MVVM with SwiftUI and Combine" +MVVM-C,Introduction to the Coordinator Pattern|Solving Navigation Concerns in MVVM|Responsibilities of the Coordinator|Flow Coordinators and Child Coordinators|Integrating MVVM-C with Existing MVVM|Advantages for Complex Navigation Flows +VIPER,"Core Components: View, Interactor, Presenter, Entity, Router|Single Responsibility Principle in VIPER|Data Flow and Communication Between Layers|Testability of VIPER Components|Advantages for Large-Scale Applications|Setting up a VIPER Module" +TCA,"Introduction to Functional Reactive Programming|Core Concepts: State, Action, Reducer, Environment|Unidirectional Data Flow in TCA|Testing Reducers and Effects|Composing Features and Reducers|Side Effects and Effects Management|Integrating TCA with SwiftUI" +Architectural Patterns,Introduction to Software Architecture|Monolithic vs Microservices Architecture|Client-Server and Layered Architectures|Model-View-Controller (MVC) Pattern|Model-View-ViewModel (MVVM) Pattern|Event-Driven Architecture Principles|Serverless Architecture Fundamentals +Reactive Programming,"Introduction to Reactive Paradigm|Core Principles: Streams, Events, Asynchrony|Push vs Pull Systems in Reactive Programming|Functional Reactive Programming (FRP) Basics|Hot vs Cold Observables Explained|Backpressure Management Strategies|Error Handling in Reactive Streams" +Publishers / Subscribers,"Introduction to Publisher-Subscriber Pattern|Core Components: Publishers, Subscribers, Events|Decoupling with Pub/Sub|Synchronous vs Asynchronous Pub/Sub|Event Buses and Message Brokers|Implementing Custom Publishers|Managing Subscriptions and Lifecycle" +Operators & Pipelines,"Introduction to Reactive Operators|Common Transformation Operators (map, flatMap, filter)|Combination Operators (combineLatest, merge, zip)|Filtering Operators (debounce, distinctUntilChanged)|Error Handling Operators (catch, retry)|Time-Based Operators (delay, throttle)|Building Complex Reactive Pipelines" +Combine and MVVM,Introduction to Apple's Combine Framework|Publishers and Subscribers in Combine|Combine Operators for Data Transformation|Integrating Combine with SwiftUI|MVVM Architecture Overview|ViewModel Design with Combine|Data Binding in MVVM using Combine|Handling User Input and State with Combine & MVVM +RxSwift,"Introduction to RxSwift and ReactiveX|Observables and Observers in RxSwift|Disposables and Memory Management|Common RxSwift Operators (map, filter, flatMap)|Subjects in RxSwift (PublishSubject, BehaviorSubject)|Schedulers for Concurrency Management|Error Handling Strategies in RxSwift" +Observables & observers,"Definition of Observables and Observers|Creating Observables (just, of, from, create)|Subscribing to Observables|Lifecycle of an Observable Subscription|Hot vs Cold Observables Explained|Unsubscribing and Resource Management|Error and Completion Events" +Subjects,Introduction to Reactive Subjects|PublishSubject: Emitting New Elements|BehaviorSubject: Emitting Last and New Elements|ReplaySubject: Emitting a Buffer of Past Elements|AsyncSubject: Emitting Only the Last Element on Completion|Using Subjects for Event Bridging|Subject as an Observable and an Observer +RxSwift with MVVM,MVVM Architecture Principles Refresher|Designing ViewModels with RxSwift|Data Binding from ViewModel to View using RxSwift|Handling User Interactions with RxSwift in MVVM|Error Handling and Loading States in MVVM|Using Drivers and Signals for UI Binding|Testing RxSwift MVVM Components +Schedulers,"Introduction to Reactive Schedulers|Purpose of Schedulers for Concurrency|Main Thread Scheduler (e.g., MainScheduler)|Background Schedulers (e.g., ConcurrentDispatchQueueScheduler)|subscribeOn vs observeOn Explained|Custom Scheduler Implementation|Best Practices for Scheduler Usage" +Delegate Pattern,"Introduction to the Delegate Design Pattern|Components: Delegating Object, Delegate Protocol|Purpose: Decoupling and Communication|Defining Delegate Protocols|Assigning and Implementing Delegates|Weak References and Memory Management|Common Use Cases in iOS/macOS" +Implementing Delegates,Step-by-Step Delegate Protocol Definition|Creating a Delegating Class/Struct|Conforming to a Delegate Protocol|Setting the Delegate Property|Calling Delegate Methods|Handling Optional Delegate Methods|Debugging Delegate Implementations +Callbacks,Introduction to Callback Functions|Synchronous vs Asynchronous Callbacks|Passing Functions as Arguments|Event Handling with Callbacks|Error Handling in Callbacks|Common Use Cases for Callbacks|Limitations of Callbacks +Closures,Introduction to Closures as Self-Contained Blocks|Closure Expression Syntax|Capturing Values from Surrounding Context|Trailing Closures and Shorthand Argument Names|Escaping vs Non-Escaping Closures|Closures as Function Parameters and Return Types|Type Aliases for Closure Types +Understanding and using Closures,Basic Closure Declaration and Invocation|Inferring Type from Context|Implicit Returns from Single-Expression Closures|Capturing Reference Types vs Value Types|Closures with Multiple Parameters and Return Values|Debugging Closure-Related Issues|Performance Considerations with Closures +Capturing Values & Memory Mgmt.,Value Capture by Closures Explained|Strong Reference Cycles with Closures|weak and unowned Capture Lists|Resolving Strong Reference Cycles in Practice|Understanding [weak self] and [unowned self]|Implicit Capture vs Explicit Capture Lists|Debugging Memory Leaks from Closures +Callback Hell,"Definition and Characteristics of Callback Hell|Nested Callbacks for Sequential Operations|Readability and Maintainability Issues|Error Handling Challenges in Callback Hell|Debugging Complex Callback Chains|Strategies to Avoid Callback Hell (e.g., Promises)|Refactoring Callback-Based Code" +Async / Await,"Introduction to Asynchronous Programming with Async/Await|async Functions and await Expressions|Structured Concurrency Principles|Error Handling with try, catch in Async/Await|Task Management and Cancellation|Bridging with Older Asynchronous APIs|Concurrency Best Practices with Async/Await" +Concurrency,Introduction to Concurrency vs Parallelism|Threads and Processes|Grand Central Dispatch (GCD) Basics|Dispatch Queues (Serial vs Concurrent)|Synchronous vs Asynchronous Tasks|Dispatch Groups and Semaphores|Race Conditions and Deadlocks|Thread Safety and Synchronization Mechanisms +Data Persistence,"Introduction to Data Persistence Concepts|User Defaults / NSUserDefaults|Property Lists (PList) for Simple Data|File System Storage (Documents, Caches Directories)|Archiving and Unarchiving Objects (Codable, NSCoding)|Core Data Framework Basics|Realm Mobile Database Fundamentals|Cloud-Based Persistence (e.g., CloudKit, Firebase)" +Core Data,Introduction to Core Data Stack|Managed Object Context and Managed Objects|Data Models and Entities|Fetch Requests and Predicates|Relationships and Fetched Properties|Migrations and Versioning|Threading with Core Data|Performance Optimization for Core Data +User Defaults,Storing Basic Data Types|Retrieving Data from User Defaults|Synchronizing User Defaults|Using Property Lists with User Defaults|Observing Changes in User Defaults|Security Considerations for User Defaults +Keychain,Introduction to Secure Storage|Storing and Retrieving Sensitive Data|Keychain Item Attributes|Querying the Keychain|Handling Keychain Errors and Security|Syncing with iCloud Keychain +File System,Understanding Sandbox and App Directories|Reading and Writing Files|Managing Directories and File Paths|File Attributes and Metadata|URL vs. String Paths for Files|Document Picker and File Providers +SQLite,"Introduction to Relational Databases|Basic SQL Commands (CREATE, INSERT, SELECT, UPDATE, DELETE)|Using SQLite.swift or Similar Wrappers|Database Schema Design and Normalization|Transactions and Concurrency in SQLite|Indexing for Performance Optimization" +JSON / XML,Introduction to Data Interchange Formats|JSON Structure and Syntax|XML Structure and Syntax|When to Use JSON vs. XML|Basic Concepts of Data Parsing|Schema Validation for JSON and XML +Parsing,Introduction to Data Parsing Techniques|JSON Parsing with JSONSerialization|Codable Protocol for JSON Parsing|XML Parsing with XMLParser|Error Handling During Parsing|Custom Data Transformations During Parsing +Serializing,Introduction to Data Serialization Techniques|JSON Serialization with JSONSerialization|Codable Protocol for JSON Encoding|PropertyList Serialization|Custom Object Serialization|Data Representation for Network Transfer +HTTP / HTTPs,"Introduction to Client-Server Communication|HTTP Request Methods (GET, POST, PUT, DELETE)|HTTP Status Codes|Request Headers and Body|HTTPS and TLS/SSL Basics|Basic RESTful Principles" +REST,"Introduction to RESTful Architecture|Resources and URIs|HTTP Methods in REST (Idempotency, Safety)|Statelessness and Caching|Request and Response Formats (JSON, XML)|Designing RESTful APIs" +URLSession,"Introduction to Network Requests|URLSession Configuration|Data Tasks, Upload Tasks, Download Tasks|Handling Responses and Errors|URLSession Delegates and Completion Handlers|Background URLSession Sessions" +Alamofire,Introduction to Alamofire|Making Basic HTTP Requests with Alamofire|Parameter Encoding and Response Handling|Uploading and Downloading Files with Alamofire|Request Interceptors and Adapters|Error Handling and Retries in Alamofire +Concurrency and Multithreading,"Introduction to Concurrency vs. Parallelism|Threads and Processes|Race Conditions and Deadlocks|Grand Central Dispatch (GCD) Basics|Operation Queues Basics|Synchronization Mechanisms (Locks, Semaphores)" +GCD,"Dispatch Queues (Serial, Concurrent, Main)|Asynchronous and Synchronous Execution|Dispatch Work Items|Dispatch Groups for Task Coordination|Dispatch Semaphores for Resource Control|Quality of Service (QoS) Classes" +Operation Queues,Introduction to Operation and OperationQueue|Creating Custom Operations|Dependencies Between Operations|Cancelling Operations|Quality of Service (QoS) for Operations|Concurrency Management with Operation Queues +Dependency Manager,"Introduction to Dependency Management|Why Use Dependency Managers|Common Problems Solved by Managers|Overview of CocoaPods, Carthage, SPM|Versioning Strategies for Dependencies|Resolving Dependency Conflicts" +CocoaPods,Installing CocoaPods|Creating a Podfile|Adding and Updating Pods|Managing Pod Versions|Troubleshooting CocoaPods Issues|Creating a Private Pod +Carthage,Installing Carthage|Creating a Cartfile|Building and Linking Frameworks|Managing Binary Dependencies|Updating Carthage Dependencies|Integrating Carthage with Xcode Projects +Swift Package Manager,Introduction to Swift Package Manager (SPM)|Creating a Package.swift Manifest|Adding Package Dependencies|Using Local and Remote Packages|Creating Custom Swift Packages|Integrating SPM with Xcode Projects +Frameworks & Library,Understanding Frameworks vs. Libraries|Static vs. Dynamic Linking|Importing and Using Frameworks|Creating Custom Frameworks|Module Stability and API Evolution|Best Practices for Dependency Selection +XCFramework,Introduction to XCFrameworks and their purpose|Creating an XCFramework from existing projects|Integrating XCFrameworks into an application|Distributing XCFrameworks for multi-platform support|Debugging and troubleshooting XCFramework integration +Static Library,Understanding Static Libraries vs. Dynamic Libraries|Creating a Static Library project in Xcode|Linking and embedding Static Libraries|Symbol visibility and name mangling in Static Libraries|Advantages and disadvantages of using Static Libraries +Dynamic Library,Understanding Dynamic Libraries and their benefits|Creating a Dynamic Library project in Xcode|Loading and linking Dynamic Libraries at runtime|Dynamic Library versioning and compatibility|Debugging and troubleshooting Dynamic Library loading issues +Accessibility Inspector,Introduction to iOS Accessibility Principles|Launching and Navigating the Accessibility Inspector|Inspecting UI Elements and their Accessibility Attributes|Identifying Common Accessibility Issues with the Inspector|Using the Accessibility Audit Feature for automated checks +Voice Over,Introduction to VoiceOver User Experience|Enabling VoiceOver and Basic Gestures|Customizing Accessibility Labels and Hints|Understanding Accessibility Traits and Values|Testing Custom UI Elements with VoiceOver +Dynamic Type,Introduction to Dynamic Type and its Importance|Supporting Dynamic Type in Standard UI Components|Using UIFontMetrics for Custom Fonts and Scaling|Responding to Content Size Category Changes|Testing Dynamic Type Across Various Text Sizes +Frameworks,"Understanding Frameworks and their Structure|Types of Frameworks (System, Embedded, Custom)|Creating a Custom Framework Project|Embedding and Linking Custom Frameworks|Framework Versioning and API Compatibility" +ARKit,"Introduction to Augmented Reality and ARKit Basics|Setting Up an ARSession and ARView|Detecting Planes and Placing Virtual Objects|Understanding AR Anchors and World Tracking|Scene Understanding and Environmental Textures|Interacting with Virtual Content (Gestures, Physics)|Persistent AR Experiences with ARWorldMap" +HealthKit,"Introduction to HealthKit Data Types and Permissions|Requesting Authorization for Health Data|Reading Health Data (Samples, Characteristics)|Writing Health Data to the Health Store|Observing Changes with HKObserverQuery|Background Delivery and Data Synchronization" +GameKit,Introduction to GameKit Features and Game Center|Player Authentication and Game Center Integration|Implementing Leaderboards and Achievements|Turn-Based Multiplayer Game Development|Real-Time Multiplayer Game Development|Integrating CloudKit for Game Data Storage +MapKit,Introduction to MapKit and Displaying Maps|Adding Annotations and Overlays to Maps|Displaying User Location and Tracking|Geocoding and Reverse Geocoding Locations|Implementing Routing and Directions|Customizing Map Appearance and Behavior +Core ML,Introduction to Machine Learning and Core ML|Converting Models to Core ML Format (.mlmodel)|Integrating Core ML Models into an iOS App|Making Predictions with Core ML|On-Device Training and Personalization with Create ML|Integrating Core ML with Vision Framework for Image Analysis +Code Quality Tools,Importance of Code Quality and Static Analysis|Overview of Different Code Quality Tool Categories|Integrating Code Quality Tools into Development Workflow|Interpreting Tool Reports and Prioritizing Fixes|Customizing Rules and Configurations for Specific Projects +SwiftLint,Introduction to SwiftLint and its Purpose|Installing and Integrating SwiftLint into Xcode|Understanding SwiftLint Rules and Violations|Configuring SwiftLint with a .swiftlint.yml File|Auto-Correcting SwiftLint Violations|Integrating SwiftLint with CI/CD Pipelines +Tailor,"Introduction to Tailor for Code Metrics Analysis|Installing and Running Tailor on Swift Projects|Understanding Tailor's Metrics (e.g., Cyclomatic Complexity)|Configuring Tailor for Specific Project Needs|Interpreting Tailor Reports and Improving Code Maintainability" +SwiftFormat,Introduction to SwiftFormat for Code Formatting|Installing and Integrating SwiftFormat|Basic Usage for Formatting Swift Code|Configuring SwiftFormat Rules and Options|Integrating SwiftFormat with Xcode and Pre-Commit Hooks +Debugging Techniques,"Understanding the Debugging Process and Tools|Setting and Managing Breakpoints (Basic, Conditional, Symbolic)|Stepping Through Code (Step Over, Step Into, Step Out)|Inspecting Variables and Memory|Using the Debug Console and LLDB Commands|Debugging Crashes and Exceptions|Advanced Debugging with Watchpoints and Thread Sanitizer" +Xcode Debugger,Overview of the Xcode Debug Area and Panes|Setting and Managing Breakpoints in Xcode|Navigating the Call Stack and Thread Explorer|Inspecting Variables in the Variables View|Using the Debug Console for LLDB Commands|Memory Graph Debugger for Leak Detection|View Debugger for UI Hierarchy Issues +Profiling Instruments,Introduction to Instruments and its Purpose|Launching Instruments and Selecting Templates|Profiling CPU Usage with Time Profiler|Detecting Memory Leaks with Leaks and Allocations|Analyzing UI Performance with Core Animation|Customizing Instruments Workflows and Data Collection|Interpreting Profiling Data for Performance Optimization +Unit & UI Testing,"Introduction to Testing Principles (Unit, UI, Integration)|Setting Up a Testing Target in Xcode|Writing Unit Tests with XCTest (Assertions, Setup/Teardown)|Mocking and Stubbing Dependencies for Unit Tests|Writing UI Tests with XCUITest (Recording, Element Queries)|Running Tests and Interpreting Results|Integrating Tests into CI/CD Pipelines" +XCTest,"Introduction to Unit Testing and XCTest|Writing Basic XCTestCase Classes|Asynchronous Testing with Expectations|Test Doubles: Mocks, Stubs, and Spies|Performance Testing with XCTest|Code Coverage Analysis with XCTest|Integrating XCTest into CI Pipelines" +XCUITest,Introduction to UI Testing and XCUITest|Recording UI Tests in Xcode|Querying and Interacting with UI Elements|Assertions and Error Handling in UI Tests|Handling System Alerts and Permissions|Implementing the Page Object Model for UI Tests|Running XCUITest on Simulators and Physical Devices +Test Plan & Coverage,Understanding Xcode Test Plans|Configuring Test Plans for Different Environments|Generating and Analyzing Code Coverage Reports|Excluding Code from Coverage|Integrating Test Plans with CI/CD Systems|Best Practices for Test Plan Management +App Store Distribution,"Apple Developer Program Enrollment and Roles|Managing App IDs and Provisioning Profiles|Creating and Managing Certificates (Development, Distribution)|Archiving and Exporting Builds for Distribution|Setting Up Your App in App Store Connect|Understanding App Store Review Guidelines|Submitting Your App for Review|Managing App Versions and Updates" +TestFlight,Introduction to TestFlight for Beta Testing|Setting Up Internal Testers and Groups|Configuring External Testers and Beta Review|Distributing Builds via TestFlight|Collecting and Managing Tester Feedback|Monitoring TestFlight Build Performance|Best Practices for Beta Testing with TestFlight +FastLane,Introduction to FastLane and its Toolset|Setting Up FastLane for iOS Projects|Automating Screenshots with `snapshot`|Automating Beta Distribution with `pilot`|Automating App Store Submissions with `deliver`|Managing Code Signing with `match`|Customizing Fastfile Lanes and Actions|Integrating FastLane with CI/CD Systems +CI / CD,"Introduction to Continuous Integration (CI)|Introduction to Continuous Delivery and Deployment (CD)|Benefits and Principles of CI/CD|Common CI/CD Pipeline Stages (Build, Test, Deploy)|Version Control System Integration|Artifact Management and Storage|Monitoring and Feedback Loops in CI/CD|Choosing and Setting Up a CI/CD Platform" +GitHub Actions,"Introduction to GitHub Actions Workflows|Workflow Syntax and Structure (YAML)|Understanding Events, Jobs, and Steps|Using Pre-built Actions from the Marketplace|Creating and Reusing Custom Actions|Managing Secrets and Environment Variables|Implementing CI/CD for Mobile Apps with GitHub Actions|Workflow Debugging and Troubleshooting" +GitLab,"Introduction to GitLab Platform and Repositories|GitLab CI/CD Fundamentals|Configuring GitLab CI/CD Pipelines (.gitlab-ci.yml)|Understanding GitLab Runners and Executors|Defining Stages, Jobs, and Artifacts|Integrating with GitLab's Container Registry|Deploying Static Sites with GitLab Pages|Advanced CI/CD Features in GitLab" +App Store Optimization (ASO),"Understanding ASO Principles and Importance|Keyword Research and Selection Strategies|Optimizing App Name, Subtitle, and Keywords Field|Designing Effective App Icons and Screenshots|Creating Compelling App Previews (Videos)|Crafting Engaging App Descriptions and Promotional Text|Localizing App Store Listings for Global Reach|Monitoring ASO Performance and Analytics" +Keeping Updated with WWDC,Understanding the Significance of WWDC|Accessing WWDC Keynotes and Session Videos|Identifying Key Announcements and New APIs|Exploring Sample Code and Developer Documentation|Applying New Features to Existing Projects|Engaging with the Apple Developer Community|Leveraging Post-WWDC Resources and Summaries +Latest Swift Version,"Understanding the Swift Evolution Process|Key Language Changes and New Syntax Features|Adopting New API Additions and Deprecations|Migration Strategies for Existing Codebases|Performance Improvements and Optimizations|Concurrency Model Updates (e.g., async/await)|Tooling and Compiler Enhancements" +Latest iOS SDK,"Overview of New iOS SDK Features and Frameworks|Exploring New APIs and System Behaviors|Adapting UI for New Device Capabilities and Sizes|Understanding Privacy and Security Enhancements|Migrating from Deprecated APIs|Adopting New System Integrations (e.g., Widgets, Live Activities)|Testing Against New iOS Versions and Betas" +New Feature Announcements,"Identifying Reliable Sources for Feature Announcements|Evaluating the Impact of New Features on Projects|Prioritizing Feature Adoption and Integration|Conducting Technical Deep Dives into New Features|Planning for Integration, Testing, and Rollout|Communicating Changes to Stakeholders|Strategies for Staying Ahead of the Curve" +HTML,"Basic HTML Document Structure (DOCTYPE, head, body)|Semantic HTML Elements for Text and Content|Creating Hyperlinks and Embedding Images|Structuring Content with Lists and Tables|Designing Forms and Input Elements|HTML5 Semantic Layout Elements (header, nav, section, footer)|Introduction to Web Accessibility (ARIA attributes)" +CSS,"CSS Syntax, Selectors (Type, Class, ID), and Specificity|Applying Styles (Inline, Internal, External Stylesheets)|Understanding the CSS Box Model (Margin, Border, Padding)|Styling Text, Colors, Backgrounds, and Fonts|Layout with Flexbox for One-Dimensional Alignment|Layout with CSS Grid for Two-Dimensional Alignment|Responsive Design with Media Queries|Introduction to CSS Transitions and Animations" +npm,"Introduction to Node.js and npm Package Manager|Initializing a Project with `npm init`|Installing and Managing Packages (`npm install`, `npm uninstall`)|Understanding `package.json` and `package-lock.json`|Running Custom Scripts with `npm run`|Semantic Versioning (SemVer) Principles|Publishing Your Own npm Packages|Security Considerations and Auditing npm Packages" +Checkpoint - Static Webpages,"Review of HTML Structure and Semantic Elements|Review of Basic CSS Styling and Layout|Creating Multi-Page Static Websites with Navigation|Embedding Media (Images, Audio, Video)|Ensuring Cross-Browser Compatibility|Basic Accessibility Checks for Static Content|Deploying a Static Website (e.g., GitHub Pages, Netlify)" +Checkpoint - Interactivity,"Introduction to JavaScript in the Browser|Basic DOM Manipulation (Selecting, Modifying Elements)|Handling User Events (Click, Hover, Input)|Implementing Client-Side Form Validation|Asynchronous JavaScript with Fetch API and Promises|Storing Data with localStorage and sessionStorage|Debugging JavaScript in Browser Developer Tools" +Checkpoint - External Packages,"Understanding the Need for External JavaScript Libraries|Using npm to Install Frontend Packages (e.g., Lodash, Axios)|Importing and Using ES Modules|Basic Concepts of JavaScript Bundlers (Webpack, Parcel)|Managing Dependencies and Package Updates|Evaluating Package Quality, Documentation, and Security|Integrating UI Component Libraries (e.g., Bootstrap, Material-UI)" +Tailwind CSS,"Introduction to Utility-First CSS|Installation and Configuration|Core Utility Classes (Layout, Typography, Colors)|Responsive Design with Tailwind Breakpoints|Customizing Tailwind Configuration (Themes, Plugins)|Directives (@apply, @layer)|Optimizing Production Builds (PurgeCSS/JIT)|Integrating with JavaScript Frameworks" +Checkpoint - Collaborative Work,"Version Control Basics (Git Fundamentals)|Branching Strategies (Git Flow, GitHub Flow)|Resolving Merge Conflicts|Code Review Best Practices|Using Project Management Tools (Jira, Trello)|Effective Communication in Teams|Pair Programming Techniques|Documenting Code and Processes" +Checkpoint - Frontend Apps,"HTML Structure and Semantics|CSS Styling and Layout Techniques|JavaScript Fundamentals for Interactivity|DOM Manipulation and Event Handling|Introduction to a Frontend Framework (e.g., React, Vue)|Component-Based Architecture|State Management in Frontend Apps|Routing in Single Page Applications|Fetching Data from APIs" +Checkpoint — CLI Apps,"Basic Command Line Operations|Parsing Command Line Arguments|Input/Output Handling (stdin, stdout, stderr)|File System Operations|Error Handling and Exit Codes|Creating Interactive Prompts|Packaging and Distribution of CLI Tools|Testing CLI Applications" +RESTful APIs,"Introduction to APIs and Web Services|HTTP Methods (GET, POST, PUT, DELETE)|Resource Identification (URIs)|Statelessness Principle|Request and Response Headers|Status Codes and Error Handling|Designing API Endpoints|Authentication and Authorization in REST|API Versioning Strategies|Tools for API Testing (Postman, Insomnia)" +Checkpoint — Simple CRUD Apps,Database Fundamentals (Relational vs. NoSQL)|Connecting to a Database|Implementing Create Operations|Implementing Read Operations (Single and List)|Implementing Update Operations|Implementing Delete Operations|Basic Data Validation|Error Handling in CRUD Operations|Building a Simple User Interface for CRUD +JWT Auth,"Introduction to Authentication and Authorization|Understanding JSON Web Tokens Structure (Header, Payload, Signature)|Token Generation and Signing|Token Verification and Validation|Implementing JWT in a Backend Application|Client-Side Storage and Usage of JWTs|Refresh Tokens for Enhanced Security|Handling Token Expiration and Revocation|Security Considerations for JWTs" +Checkpoint — Complete App,Full-Stack Project Planning and Architecture|Integrating Frontend and Backend|Implementing User Authentication and Authorization|Database Schema Design and Migrations|Handling File Uploads and Storage|Deployment Strategies for Full-Stack Apps|Testing End-to-End Functionality|Performance Optimization Basics|Monitoring and Logging for Production +Basic AWS Services,"AWS Global Infrastructure (Regions, AZs)|AWS Management Console Navigation|Identity and Access Management (IAM) Fundamentals|Introduction to Compute Services (EC2, Lambda)|Introduction to Storage Services (S3, EBS)|Introduction to Networking (VPC Basics)|Billing and Cost Management Basics|AWS Shared Responsibility Model" +EC2,"Understanding EC2 Instances and Types|Launching and Connecting to EC2 Instances|Security Groups and Network ACLs|Elastic IP Addresses|EBS Volumes and Snapshots|Instance Store vs. EBS|Auto Scaling Groups and Load Balancers|Monitoring EC2 with CloudWatch|EC2 Pricing Models (On-Demand, Reserved, Spot)" +VPC,"Introduction to Virtual Private Cloud|VPC Components (Subnets, Route Tables, Internet Gateways)|Network Access Control Lists (NACLs) vs. Security Groups|NAT Gateways and Instances|VPC Peering|VPN Connections and Direct Connect|Flow Logs for Network Monitoring|Designing Multi-Tier Architectures within a VPC" +Route53,"Introduction to DNS and Domain Names|Route 53 Hosted Zones|Common DNS Record Types (A, CNAME, MX, TXT)|Routing Policies (Simple, Weighted, Latency, Failover, Geolocation)|Domain Registration with Route 53|Health Checks and DNS Failover|Integrating Route 53 with other AWS Services (ELB, CloudFront)|Private Hosted Zones" +SES,"Introduction to Email Sending Services|Verifying Identities (Domains, Email Addresses)|Sending Emails (SMTP, API)|Email Templates and Personalization|Handling Bounces and Complaints|Email Sending Limits and Quotas|Monitoring Email Activity with CloudWatch|Security Best Practices for SES" +S3,"Introduction to Object Storage|S3 Buckets and Objects|Bucket Policies and Access Control Lists (ACLs)|Versioning and Lifecycle Management|Static Website Hosting|S3 Storage Classes (Standard, IA, Glacier, Deep Archive)|Pre-signed URLs|Cross-Region Replication|Event Notifications" +Monit,"Introduction to System Monitoring|Installing and Configuring Monit|Monitoring Processes and Services|Monitoring File System Changes|Monitoring System Resources (CPU, Memory, Disk)|Configuring Alerts and Notifications|Restarting Failed Services Automatically|Monit Web Interface|Advanced Monit Configuration" +Checkpoint — Deployment,"Understanding Deployment Environments (Dev, Staging, Prod)|Manual vs. Automated Deployment|Containerization for Deployment (Docker)|Orchestration for Deployment (Kubernetes Basics)|Cloud Deployment Strategies (IaaS, PaaS, Serverless)|Blue/Green and Canary Deployments|Rollback Strategies|Post-Deployment Verification and Health Checks|Infrastructure as Code Basics (Terraform, CloudFormation)" +Checkpoint — Monitoring,"Importance of Monitoring and Observability|Key Metrics to Monitor (System, Application, Network)|Logging Best Practices and Centralized Logging|Alerting and Notification Systems|Dashboarding and Visualization Tools|Tracing and Distributed Tracing Concepts|Incident Response and Runbooks|Performance Monitoring and Optimization|Synthetic Monitoring and Uptime Checks" +Ansible,"Introduction to Configuration Management|Ansible Architecture and Components|Inventory Management|Writing Playbooks (Tasks, Handlers, Variables)|Modules and Ad-Hoc Commands|Roles for Reusability|Ansible Vault for Sensitive Data|Conditionals, Loops, and Error Handling|Ansible Galaxy and Collections|Integrating Ansible with CI/CD" +Checkpoint — CI / CD,"Introduction to CI/CD Principles|Version Control System Integration|Automated Build Process|Automated Testing (Unit, Integration, E2E)|Artifact Management|Continuous Integration Pipelines|Continuous Delivery vs. Continuous Deployment|Setting up a CI/CD Pipeline (e.g., Jenkins, GitLab CI, GitHub Actions)|Deployment Strategies within CI/CD" +Checkpoint — Automation,"Principles of Automation|Scripting Fundamentals (Bash, Python)|Task Scheduling (Cron Jobs)|Infrastructure as Code (IaC) Concepts|Configuration Management Tools (Ansible, Puppet, Chef)|Orchestration Tools (Docker Compose, Kubernetes)|CI/CD Pipeline Automation|Monitoring and Alerting Automation|Automated Testing Frameworks|Security Automation" +Checkpoint — Infrastructure,"Virtualization and Containerization Basics|Networking Fundamentals (IP, DNS, Load Balancers)|Storage Systems (Block, File, Object Storage)|Infrastructure as Code (IaC) Principles|Cloud Infrastructure Concepts (IaaS, PaaS, SaaS)|High Availability and Disaster Recovery Strategies|Infrastructure Monitoring and Alerting|Security Best Practices for Infrastructure" +Programming Fundamentals,"Variables, Data Types, and Operators|Control Flow (Conditionals and Loops)|Functions and Modularity|Basic Data Structures (Arrays, Lists, Dictionaries)|Object-Oriented Programming Concepts (Introduction)|Error Handling and Debugging|File I/O Operations|Algorithms and Computational Thinking" +Go,"Go Language Syntax and Basic Types|Control Structures and Functions in Go|Packages and Modules for Code Organization|Pointers and Memory Management|Concurrency with Goroutines and Channels|Error Handling and Defer Statements|Interfaces and Polymorphism|Testing and Benchmarking in Go|Standard Library Usage (e.g., net/http, encoding/json)" +Bash,"Basic Shell Commands and Navigation|Input/Output Redirection and Pipes|Variables, Aliases, and Environment Variables|Conditional Statements and Loops in Bash|Functions and Script Arguments|Regular Expressions and Text Processing Tools (grep, sed, awk)|Job Control and Process Management|Shell Script Debugging and Best Practices" +Version Control Systems,"Introduction to Version Control Concepts|Git Basic Commands (init, add, commit, status, diff)|Branching and Merging Workflows|Remote Repositories (GitHub/GitLab/Bitbucket)|Resolving Merge Conflicts|Undoing Changes and History Rewriting (revert, reset)|Collaborative Workflows (Pull Requests/Merge Requests)|Advanced Git Features (Stashing, Rebasing)" +AWS / Azure / GCP,"Cloud Computing Concepts and Service Models (IaaS, PaaS, SaaS)|Core Compute Services (EC2, Azure VMs, GCE)|Core Storage Services (S3, Azure Blob, GCS)|Networking Fundamentals in the Cloud (VPCs, Subnets, Security Groups)|Identity and Access Management (IAM)|Database Services (RDS, Azure SQL, Cloud SQL)|Serverless Computing Concepts (Lambda, Azure Functions, Cloud Functions)|Cost Management and Optimization in the Cloud" +Cloud-native ML Services,"Introduction to Cloud ML Platforms (SageMaker, Azure ML, Vertex AI)|Managed Data Labeling Services|Automated Machine Learning (AutoML)|Pre-trained Models and APIs (Vision, NLP, Speech)|Managed Notebook Environments for ML Development|Model Deployment and Hosting Services|Monitoring and MLOps Features of Cloud Platforms|Cost Optimization for Cloud ML Workloads" +Data Engineering Fundamentals,"Relational vs. Non-Relational Databases|SQL for Data Manipulation and Querying|Data Modeling Concepts (Star Schema, Snowflake Schema)|ETL/ELT Processes and Data Pipelines|Data Warehousing Concepts (OLAP vs OLTP)|Introduction to Big Data Technologies (Hadoop, Spark)|Data Governance and Quality Principles|Data Security and Privacy in Data Engineering" +Data Lakes & Warehouses,"Distinction between Data Lakes and Data Warehouses|Data Lake Architecture and Components (Storage, Catalog)|Data Warehouse Architecture and Design Principles|Schema-on-Read vs. Schema-on-Write|Data Ingestion Strategies for Lakes and Warehouses|Data Processing Frameworks for Lakes (Spark, Hive)|Querying Data Lakes (Presto, Athena, BigQuery)|Data Lakehouse Concepts and Implementations" +Data Ingestion Architecture,"Batch vs. Stream Processing Concepts|Data Sources and Connectors|Message Queues and Event Streaming (Kafka, Kinesis, Pub/Sub)|Change Data Capture (CDC) Techniques|ETL/ELT Tools and Frameworks|Data Validation and Quality Checks during Ingestion|Scalability and Reliability in Ingestion Pipelines|Monitoring and Alerting for Data Ingestion" +MLOps Principles,"Introduction to MLOps and its Importance|Reproducibility in Machine Learning|Version Control for Code, Data, and Models|CI/CD for Machine Learning Models|Automated Testing for ML Pipelines|Model Deployment Strategies (Batch, Real-time, Edge)|Monitoring and Observability for ML Models|ML Governance and Compliance" +MLOps Components,"Experiment Tracking Systems|Model Registries and Versioning|Feature Stores for Data Management|ML Pipeline Orchestration Tools (Kubeflow, Airflow, MLflow)|Model Serving Infrastructure (Kubernetes, Serverless)|Data and Model Monitoring Tools|Automated Retraining and Redeployment|Infrastructure as Code for MLOps Resources" +Experiment Tracking & Model Registry,"Importance of Experiment Tracking in ML|Logging Metrics, Parameters, and Artifacts|Comparing and Reproducing Experiments|Introduction to Model Registries|Model Versioning and Lifecycle Management|Model Metadata and Tagging|Model Approval and Staging Workflows|Integration with MLOps Pipelines" +Data Lineage & Feature Stores,Understanding Data Lineage and its Value|Tracking Data Transformations and Dependencies|Data Governance and Compliance with Lineage|Introduction to Feature Stores|Online vs. Offline Feature Serving|Feature Versioning and Management|Feature Engineering Best Practices|Integration of Feature Stores with ML Pipelines +Model Training & Serving,"Machine Learning Model Training Workflows|Distributed Training Concepts|Hyperparameter Optimization Techniques|Model Evaluation and Validation Metrics|Model Serialization and Deserialization|Model Deployment Strategies (REST APIs, Batch Inference)|Scalable Model Serving Infrastructure|A/B Testing and Canary Deployments for Models" +Monitoring & Observability,"Distinction between Monitoring and Observability|Key Metrics for System Health (CPU, Memory, Network)|Logging Best Practices and Centralized Logging|Tracing for Distributed Systems|Alerting Strategies and Incident Management|Dashboarding and Visualization Tools|Application Performance Monitoring (APM)|SLOs, SLAs, and Error Budgets" +Kotlin,"Kotlin Basic Syntax and Data Types|Control Flow (Conditionals, Loops) and Functions|Null Safety and Type System|Classes, Objects, and Object-Oriented Programming in Kotlin|Collections and Lambdas|Extension Functions and Properties|Coroutines for Asynchronous Programming|Interoperability with Java|Domain-Specific Languages (DSLs) with Kotlin" +Development IDE,"Introduction to IDEs and their Purpose|Basic IDE Navigation and Project Setup|Code Editing Features (Syntax Highlighting, Autocompletion)|Debugging Tools and Techniques|Version Control Integration within IDEs|Refactoring Tools and Code Analysis|Plugin and Extension Management|Customizing IDE Settings and Shortcuts" +Basics of Kotlin,"Setting Up Kotlin Development Environment|First Kotlin Program: ""Hello World""|Variables (var, val) and Basic Data Types|Operators and Expressions|Conditional Statements (if, when)|Looping Constructs (for, while)|Functions and Parameters|Introduction to Null Safety" +Basics of OOP,Introduction to Object-Oriented Paradigm|Classes and Objects|Attributes (Fields) and Methods|Encapsulation and Access Modifiers|Inheritance and Polymorphism|Abstraction and Interfaces|Constructors and Object Instantiation|Design Principles (SOLID Introduction) +What is and how to use Gradle?,"Introduction to Build Automation and Gradle|Gradle Build Script Basics (Groovy/Kotlin DSL)|Tasks, Dependencies, and Plugins|Managing Project Dependencies|Multi-Project Builds|Custom Tasks and Plugins|Gradle Daemon and Build Caching|Integrating Gradle with IDEs" +Create a Basic Hello World App,"Setting up Android Studio and SDK|Creating a New Android Project|Understanding Android Project Structure|Designing a Simple Layout with XML|Writing Basic UI Logic (TextView, Button)|Running the App on Emulator or Device|Basic Debugging Techniques" +Bitbucket,Introduction to Version Control Systems (Git)|Bitbucket Account Setup and Repository Creation|Cloning Repositories and Basic Git Commands|Branching and Merging Workflows|Pull Requests and Code Reviews|Bitbucket Pipelines for CI/CD|Jira Integration and Project Management|Repository Permissions and Security +App Components,Overview of Android Application Structure|Introduction to Activities|Introduction to Services|Introduction to Content Providers|Introduction to Broadcast Receivers|Inter-Component Communication with Intents|Component Lifecycle Management Overview +Activity,Definition and Purpose of an Activity|Creating and Launching Activities|Activity Lifecycle Methods|Designing User Interfaces with Layouts|Handling User Input and Events|Passing Data Between Activities (Intents)|Activity Stacks and Back Navigation +Services,"Definition and Purpose of a Service|Types of Services (Foreground, Background, Bound)|Creating and Starting/Stopping Services|Service Lifecycle Methods|Interacting with Bound Services|Handling Long-Running Operations|Permissions and Security Considerations for Services" +Content Provider,"Definition and Purpose of a Content Provider|Content Provider URI Structure|Querying Data with Content Resolvers|Inserting, Updating, and Deleting Data|Creating Custom Content Providers|Permissions and Data Security|Content Observers for Data Change Notifications" +Broadcast Receiver,"Definition and Purpose of a Broadcast Receiver|Types of Broadcasts (System, Custom)|Registering Receivers (Manifest vs. Context)|Handling Broadcast Intents|Ordered vs. Unordered Broadcasts|Security Considerations for Broadcasts|Local Broadcast Manager" +Activity LifeCycle,"Understanding Activity States (Created, Started, Resumed)|Key Lifecycle Callback Methods (onCreate, onStart, onResume, onPause, onStop, onDestroy)|Saving and Restoring Activity State (onSaveInstanceState)|Handling Configuration Changes (Orientation, Keyboard)|Lifecycle-Aware Components (ViewModel, LiveData)|Practical Scenarios and Best Practices" +State Changes,Understanding UI State vs. Application State|Saving and Restoring Activity/Fragment State (Bundle)|ViewModel for UI-related Data Persistence|LiveData and StateFlow for Observable Data|Handling Configuration Changes Gracefully|Managing Complex UI States|Architectural Patterns for State Management +Tasks & Backstack,"Definition of Tasks and the Back Stack|Launching Modes for Activities (standard, singleTop, singleTask)|Manipulating the Back Stack with Intent Flags|Understanding Task Affinities|Handling Deep Links and Navigation|User Experience and Navigation Principles|Recent Apps Screen Behavior" +Implicit Intents,"Introduction to Intents and Their Purpose|Components of an Implicit Intent (Action, Data, Category)|Resolving Implicit Intents (Intent Resolution Process)|Using Common Implicit Intents (e.g., dialer, browser)|Handling Multiple Matching Apps (Chooser)|Verifying Intent Availability|Security Considerations for Implicit Intents" +Explicit Intents,Introduction to Explicit Intents|Specifying Target Component (Class Name)|Starting Activities with Explicit Intents|Starting Services with Explicit Intents|Passing Data with Extras (Bundle)|Retrieving Results from Started Activities (Activity Result API)|Best Practices for Inter-Component Communication +Intent Filters,"Purpose and Structure of Intent Filters|Matching Rules (Action, Data, Category)|Declaring Intent Filters in Android Manifest|Making Activities Discoverable|Handling Deep Links and Custom URL Schemes|Security Implications of Broad Intent Filters|Testing Intent Filter Behavior" +Design & Architecture,"Principles of Good Software Design (SOLID, DRY)|Common Android Architectural Patterns (MVC, MVP, MVVM)|Separation of Concerns and Modularity|Data Layer Design (Repositories, Data Sources)|UI Layer Design (Fragments, Activities, Composables)|Dependency Injection Frameworks (Dagger Hilt, Koin)|Testing Strategies (Unit, Integration, UI Testing)|Clean Architecture Principles" +Frame,"Introduction to Android Layouts|Purpose and Characteristics of FrameLayout|Overlapping Views within a FrameLayout|Gravity Attributes for Child Positioning|Use Cases for FrameLayout (e.g., image overlays)|Performance Considerations|Comparison with other Layouts" +Linear,Introduction to LinearLayout|Orientation (Horizontal vs. Vertical)|Weight Attribute for Proportional Distribution|Gravity and Layout Gravity|Nesting LinearLayouts|Use Cases and Best Practices|Performance Implications of Deep Nesting +Relative,"Introduction to RelativeLayout|Positioning Views Relative to Parent|Positioning Views Relative to Siblings|Alignment Attributes (e.g., alignParentTop, centerInParent)|Anchoring Views|Use Cases for Complex Layouts|Performance Considerations and Alternatives (ConstraintLayout)" +Constraint,"Introduction to ConstraintLayout and its Advantages|Basic Constraints (Parent, Sibling)|Chains (Packed, Spread, Spread Inside)|Guidelines and Barriers|Dimensions and Ratios|ConstraintLayout Editor Usage|Performance and Flattened View Hierarchies|Responsive UI Design with ConstraintLayout" +RecyclerView,"Introduction to RecyclerView vs. ListView|Core Components: Adapter, ViewHolder, LayoutManager|Creating a Custom Adapter|Implementing ViewHolder Pattern|Different Layout Managers (LinearLayoutManager, GridLayoutManager)|Handling Item Clicks and Interactions|Optimizations (DiffUtil, ItemDecorations)|Data Binding with RecyclerView|Pagination and Infinite Scrolling" +Flow,"Introduction to Reactive Programming and Cold Streams|Creating Flows: flow builder, asFlow(), channelFlow|Flow Operators: map, filter, transform, onEach|Terminal Operators: collect, first, single, reduce|Flow Context and Concurrency: flowOn, buffer, conflate, collectLatest|Error Handling in Flows: catch, retry, onCompletion|StateFlow and SharedFlow for Hot Streams|Testing Flows" +RxJava,"Introduction to Reactive Programming and Observables|Creating Observables: just, fromArray, create, defer|Observable Operators: map, filter, flatMap, zip, combineLatest|Schedulers for Concurrency: io, computation, mainThread|Error Handling in RxJava: onErrorReturn, retry, onErrorResumeNext|Backpressure Strategies: Flowable vs Observable|Composables: Single, Maybe, Completable|RxJava with Android: RxBinding, Lifecycle management" +RxKotlin,Introduction to RxKotlin and Kotlin Extensions for RxJava|Creating Observables with Kotlin DSLs|Kotlin-specific Operators and Extensions|Type-safe Builders for RxJava Components|Integrating RxKotlin with Coroutines|Error Handling in RxKotlin|Testing RxKotlin Streams +LiveData,"Introduction to Android Architecture Components|LiveData Basics: Observers and Lifecycle Awareness|Creating and Updating LiveData: MutableLiveData|Transformations with LiveData: map, switchMap|MediatorLiveData for Combining Sources|LiveData with Coroutines: liveData builder|Testing LiveData" +Dependency Injection,"Understanding Coupling and Cohesion|Inversion of Control (IoC) Principle|Constructor, Setter, and Interface Injection|Benefits of Dependency Injection: Testability, Maintainability|Service Locators vs. Dependency Injection Frameworks|Scoping and Component Lifecycles|Common DI Patterns and Anti-patterns" +Dagger,Introduction to Dagger 2 and Annotation Processing|@Module and @Provides for Dependencies|@Component for Injector Graph|@Inject for Field and Constructor Injection|Scoping with @Scope Annotations|Subcomponents and Component Dependencies|Custom Scopes and Multibindings|Testing Dagger Components +Koin,"Introduction to Koin DSL and Module Declaration|`single`, `factory`, `viewModel` Definitions|Injecting Dependencies: `by inject()`, `get()`|Koin Scopes and Parameters|Testing Koin Modules|Koin with Android: Android Koin modules|Advanced Koin Features: Properties, Bindings" +Hilt,Introduction to Hilt and Dagger Integration|@HiltAndroidApp and @AndroidEntryPoint|@Module and @Provides for Hilt Modules|Predefined Components and Scopes|Injecting Dependencies with @Inject|ViewModel Injection with @HiltViewModel|Testing Hilt Applications|Customizing Hilt Components +Kodein,"Introduction to Kodein-DI and its DSL|Binding Dependencies: `bind`, `singleton`, `factory`|Retrieving Dependencies: `instance()`, `provider()`|Kodein Scopes and Context|Kodein with Android: Android Kodein extensions|Testing Kodein Modules|Advanced Kodein Features: Overriding, Type Erasure" +Storage,Understanding Data Persistence Needs|Internal vs. External Storage|File Storage Basics: Reading and Writing Files|Choosing the Right Storage Solution|Data Security and Encryption Considerations|Backup and Restore Strategies|Permissions for Storage Access +Shared Preferences,Introduction to Key-Value Storage|Storing Primitive Data Types|Reading and Writing Data with SharedPreferences|Applying Changes: `apply()` vs `commit()`|Handling Data Migrations|Limitations and Best Practices|Using Jetpack DataStore as an alternative +DataStore,Introduction to Jetpack DataStore|Preferences DataStore vs. Proto DataStore|Creating and Managing Preferences DataStore|Reading and Writing Data with Preferences DataStore (Flow API)|Defining Schemas with Protocol Buffers for Proto DataStore|Implementing Proto DataStore: Serializer and Data Class|Error Handling and Data Migration in DataStore|Testing DataStore Implementations +Room Database,"Introduction to SQLite and ORM Libraries|Defining Entities with @Entity|Creating Data Access Objects (DAOs) with @Dao|Building the Room Database with @Database|Performing CRUD Operations (Insert, Query, Update, Delete)|Type Converters for Custom Data Types|Database Migrations and Versioning|Testing Room Databases" +Network,"Understanding Client-Server Architecture|HTTP/HTTPS Protocols and Request Methods (GET, POST, PUT, DELETE)|JSON and XML Data Formats|RESTful APIs Principles|Handling Network Connectivity and Errors|Authentication and Authorization in Network Requests|Security Considerations: SSL Pinning, Data Encryption|Caching Network Responses" +Retro,"Introduction to Retrofit for Type-Safe HTTP Clients|Defining API Interfaces with Annotations|Configuring Retrofit: Base URL, Converters (Gson, Moshi)|Making Synchronous and Asynchronous Requests|Handling Network Responses and Errors|Interceptors for Request/Response Modification|Authentication with Retrofit (e.g., OAuth, Bearer Tokens)|File Uploads and Downloads with Retrofit" +OkHttp,"Introduction to OkHttp as an HTTP Client|Building Requests with Request.Builder|Executing Requests Synchronously and Asynchronously|Handling Responses and Response Bodies|Interceptors for Logging, Caching, and Authentication|Connection Pooling and HTTP/2 Support|Error Handling and Retries|OkHttp with WebSockets" +Apollo-Android,"Introduction to GraphQL and Apollo Client|Defining GraphQL Schemas and Operations (Queries, Mutations, Subscriptions)|Generating Kotlin/Java Models from GraphQL Schema|Executing GraphQL Queries and Mutations|Handling GraphQL Responses and Errors|Caching Strategies with Apollo Client|Authentication and Authorization with Apollo|Integrating Apollo with Android UI (e.g., LiveData, Flow)" +Asynchronism,"Understanding Blocking vs. Non-Blocking Operations|The Need for Asynchronous Programming|Callbacks and Listener Patterns|Futures and Promises (e.g., Java's Future, Kotlin's Deferred)|Event Loops and Message Queues|Error Handling in Asynchronous Code|Concurrency vs. Parallelism|Introduction to Reactive Programming Paradigms" +Coroutines,"Introduction to Coroutines and Structured Concurrency|`launch` and `async` Builders for Coroutine Scope|Dispatchers for Thread Management (Main, IO, Default)|Suspending Functions and `suspend` Keyword|Coroutine Context and Job Hierarchy|Error Handling in Coroutines: `try-catch`, `CoroutineExceptionHandler`|Cancellation and Timeout Mechanisms|Flow for Asynchronous Data Streams" +Threads,"Introduction to Processes and Threads|Creating and Managing Threads in Java/Kotlin|Thread Lifecycle and States|Synchronization Primitives: `synchronized`, Locks, Semaphores|Thread Pools and Executors|Inter-Thread Communication: `wait()`, `notify()`, `notifyAll()`|Common Concurrency Issues: Deadlock, Race Conditions|Android Main Thread (UI Thread) and Background Threads" +TextView,"Basic Text Display and Properties|Text Styling (Color, Size, Font Family)|String Resources and Internationalization|Clickable and Selectable Text|Custom Fonts and Typefaces|Spans for Advanced Text Formatting" +Fragments,Introduction to Fragments and Lifecycle|Adding Fragments Dynamically and Statically|Fragment Manager and Transactions|Communicating Between Fragments and Activities|Fragment Back Stack Management|Handling Configuration Changes with Fragments|Nested Fragments +EditText,Basic Text Input and Properties|Input Types and Keyboard Management|Hint Text and Error Handling|Monitoring Text Changes with TextWatcher|Input Filters and Formatters|Auto-completion and Suggestions|Customizing Keyboard Actions +Dialogs,Introduction to AlertDialog and Basic Usage|Customizing AlertDialog Layouts|DatePickerDialog and TimePickerDialog|Creating Custom Dialogs with Dialog Class|Managing Dialogs with DialogFragment|Handling Dialog State and Lifecycle Events +Buttons,"Basic Button Creation and Click Handling|Button Styling and Customization|ImageButton and ToggleButton|Material Design Button Types (e.g., MaterialButton)|State-List Drawables for Visual Feedback|Accessibility for Buttons" +Toast,"Basic Toast Message Display|Toast Duration and Positioning|Customizing Toast Layouts|Best Practices and Alternatives (e.g., Snackbar)" +ImageView,"Displaying Images from Resources and Assets|ScaleType and AdjustViewBounds Properties|Tinting and Color Filters|Loading Images from External Sources (e.g., URL with Glide/Picasso)|Vector Drawables and SVG Support|Image Manipulation and Transformations" +Bottom Sheet,Introduction to Bottom Sheets (Modal vs. Persistent)|Implementing Modal BottomSheetDialog|Implementing Persistent Bottom Sheets with BottomSheetBehavior|Bottom Sheet States and Callbacks|Customizing Bottom Sheet Appearance and Content|Interacting with Bottom Sheet Content and Lifecycle +ListView,Introduction to ListView and ArrayAdapter|Custom Adapters with BaseAdapter|ViewHolder Pattern for Performance Optimization|Handling Item Clicks and Long Clicks|Customizing Item Layouts|Performance Considerations and Limitations (leading to RecyclerView) +Drawer,Introduction to Navigation Drawer and DrawerLayout|Setting up DrawerLayout with NavigationView|Managing Drawer Open/Close States|Handling Navigation Item Selections|Customizing Drawer Content and Header|Integrating with Navigation Components +Tabs,Introduction to Tabs and TabLayout|Integrating TabLayout with ViewPager/ViewPager2|Adding Icons and Custom Views to Tabs|Handling Tab Selection Events|Styling and Customizing Tab Appearance|Dynamic Tab Management +Animations,"Introduction to View Animations (Tween Animations)|Property Animations (ObjectAnimator, ValueAnimator)|AnimatorSet for Orchestrating Multiple Animations|Interpolators and TypeEvaluators|Transition Framework for Layout Changes|Shared Element Transitions|Lottie and Physics-Based Animations" +Jetpack Compose,"Introduction to Declarative UI and Composables|Basic UI Elements and Modifiers|State Management in Compose (remember, mutableStateOf)|Layouts (Column, Row, Box) and Custom Layouts|Lists with LazyColumn and LazyRow|Navigation in Compose|Theming and Material Design in Compose|Side Effects and Lifecycle (LaunchedEffect, DisposableEffect)|Testing Jetpack Compose UI" +App Shortcuts,Introduction to App Shortcuts|Implementing Static Shortcuts|Implementing Dynamic Shortcuts with ShortcutManager|Pinning Shortcuts to Launcher|Shortcut Intents and Deep Linking|Best Practices and Guidelines +Navigation Components,"Introduction to Navigation Components and Graph|NavHostFragment and NavController|Defining Destinations and Actions|Passing Data Between Destinations (Arguments, Safe Args)|Deep Linking with Navigation Components|Integrating with Bottom Navigation and Navigation Drawer|Conditional Navigation and Global Actions" +MVI,"Introduction to MVI Architecture Pattern|Core Components: Model, View, Intent|Unidirectional Data Flow Principle|State Management and Immutability|Handling Side Effects and Asynchronous Operations|Implementing MVI with Kotlin Coroutines and Flow|Testing MVI Components" +Repository Pattern,"Introduction to the Repository Pattern|Benefits and Goals of the Pattern|Abstracting Data Sources (Local, Remote, Cache)|Defining Repository Interfaces|Implementing Concrete Repositories|Integrating with ViewModel and Use Cases|Testing Repository Implementations" +Builder Pattern,"Introduction to the Builder Pattern|Problem Solved: Complex Object Construction|Core Components: Builder and Product|Step-by-Step Object Construction|Ensuring Immutability with Builder|Practical Use Cases and Examples (e.g., AlertDialog.Builder)|Fluent API Design with Builder" +Factory Pattern,Introduction to the Factory Pattern|Problem Solved: Decoupling Object Creation|Simple Factory Implementation|Factory Method Pattern|Abstract Factory Pattern|When to Use Each Factory Type|Practical Examples and Use Cases +Observer Pattern,"Introduction to the Observer Pattern|Core Components: Subject (Observable) and Observer|Subscription and Notification Mechanism|Push vs. Pull Model for Updates|Benefits and Common Use Cases|Implementing the Pattern in Java/Kotlin|Modern Alternatives (LiveData, Flow, RxJava)" +WorkManager,Introduction to WorkManager and Use Cases|Defining Work with Worker Classes|Creating OneTimeWorkRequests and PeriodicWorkRequests|Applying Constraints to WorkRequests|Passing Input and Output Data to Work|Chaining and Combining WorkRequests|Observing Work Status and Results|Testing WorkManager Implementations +Common Services,"Android Application Lifecycle Fundamentals|Background Processing with Threads and Coroutines|Runtime Permissions Management|Displaying Notifications and Notification Channels|Using Broadcast Receivers for System Events|Introduction to Android Services (Foreground, Background, Bound)|Content Providers Basics for Data Sharing|Scheduling Tasks with AlarmManager" +Crashlytics,Introduction to Crashlytics and Error Reporting|Setting Up Crashlytics in an Android Project|Logging Non-Fatal Errors and Custom Keys|Reporting Caught Exceptions Manually|Adding User-Specific Data to Crash Reports|Analyzing Crash Reports in the Firebase Console|Integrating Crashlytics with Other Firebase Products|Best Practices for Crash Reporting and Debugging +Remote Config,Introduction to Remote Config and Dynamic App Behavior|Setting Up Remote Config in an Android Project|Defining Parameters and Default Values|Fetching and Activating Config Values|Real-time Updates and A/B Testing Integration|User Targeting and Personalization|Error Handling and Fallback Strategies|Best Practices for Remote Config Management +Cloud Messaging,Introduction to Firebase Cloud Messaging (FCM) Architecture|Setting Up FCM in an Android Project|Receiving Downstream and Upstream Messages|Handling Data Messages and Notification Messages|Implementing Notification Channels for Android O+|Sending Messages via Topic Messaging and Device Groups|Sending Messages from a Server using FCM HTTP v1 API|Advanced FCM Features: Message Priority and Time-to-Live +FireStore,"Introduction to Firestore: NoSQL, Real-time Database|Setting Up Firestore in an Android Project|Firestore Data Model: Collections, Documents, Fields|Reading Data: Get Operations and Real-time Listeners|Writing Data: Add, Set, Update, and Delete Operations|Querying Data: Filtering, Ordering, and Limiting|Implementing Transactions and Batched Writes|Firestore Security Rules and Offline Persistence" +Google Admob,"Introduction to AdMob and Mobile App Monetization|Setting Up AdMob in an Android Project|Implementing Banner Ads|Implementing Interstitial Ads|Implementing Rewarded Video Ads|Implementing Native Ads|Ad Targeting, Consent (GDPR/CCPA), and Privacy|Ad Mediation and Optimization Strategies" +Google Play Services,Introduction to Google Play Services and its Role|Checking for Google Play Services Availability|Integrating Common APIs: Location and Sign-in|Using FusedLocationProviderClient for Location Services|Implementing Google Sign-In for Authentication|Handling API Connection Failures and Updates|Understanding API Scopes and Permissions|Best Practices for Google Play Services Integration +Google Maps,"Introduction to Google Maps Platform for Android|Setting Up Google Maps SDK in an Android Project|Displaying a Basic Map with MapFragment/MapView|Adding Markers and Info Windows to the Map|Drawing Shapes: Polylines, Polygons, and Circles|Customizing Map Appearance and Styles|Controlling Camera Movement and User Interaction|Location Tracking and Geocoding/Reverse Geocoding" +Ktlint,"Introduction to Ktlint: Kotlin Linter and Formatter|Setting Up Ktlint in a Gradle Project|Understanding Ktlint Rules and Conventions|Running Ktlint Checks Manually and in CI|Auto-Formatting Code with Ktlint|Integrating Ktlint with IDEs (e.g., Android Studio)|Configuring Ktlint for Specific Project Needs|Best Practices for Maintaining Code Style with Ktlint" +Detekt,"Introduction to Detekt: Static Analysis for Kotlin|Setting Up Detekt in a Gradle Project|Understanding Detekt Rule Sets (Code Smells, Complexity)|Configuring Detekt Rules and Baselines|Running Detekt Checks Manually and in CI|Generating Detekt Reports (HTML, XML)|Integrating Detekt with IDEs|Customizing Detekt Rules (Advanced)" +Timber,Introduction to Timber: A Logging Library for Android|Setting Up Timber in an Android Project|Basic Logging with Timber.plant()|Creating Custom Timber Trees|Implementing Debug vs. Release Logging Strategies|Formatting Log Messages and Arguments|Integrating Timber with Crash Reporting Tools|Best Practices for Effective Logging with Timber +Leak Canary,"Introduction to LeakCanary: Memory Leak Detection|Setting Up LeakCanary in an Android Project|Understanding Common Android Memory Leaks|Interpreting LeakCanary Reports and Stack Traces|Identifying Leak Patterns (Context, Listeners, Inner Classes)|Debugging and Fixing Memory Leaks|Customizing LeakCanary Behavior and Configuration|Best Practices for Preventing Memory Leaks" +Chucker,"Introduction to Chucker: HTTP Inspector for Android|Setting Up Chucker in an Android Project|Intercepting Network Requests and Responses|Viewing Network Traffic in the Chucker UI|Analyzing Request/Response Headers and Bodies|Sharing Network Logs for Debugging|Debugging API Issues with Chucker|Customizing Chucker for Production Builds (e.g., Obfuscation)" +Jetpack Benchmark,Introduction to Jetpack Benchmark Library|Setting Up a Benchmark Module in an Android Project|Writing Microbenchmarks for Kotlin/Java Code|Writing Macrobenchmarks for UI and App Performance|Understanding Benchmark Results and Metrics|Identifying Performance Bottlenecks|Integrating Benchmarks into CI/CD Pipelines|Best Practices for Writing Effective Benchmarks +Testing,"Introduction to the Android Testing Pyramid|Unit Testing Principles and Frameworks (JUnit)|Integration Testing Concepts and Strategies|UI Testing Principles and Frameworks (Espresso)|Test Doubles: Mocks, Stubs, and Fakes|Test-Driven Development (TDD) in Android|Setting Up Testing Environments (Local, Device, Emulator)|Continuous Integration for Android Tests" +Espresso,"Introduction to Espresso: UI Testing Framework|Setting Up Espresso in an Android Project|Basic ViewMatchers, ViewActions, and ViewAssertions|Interacting with RecyclerViews and Dialogs|Handling Asynchronous Operations with Idling Resources|Testing Intents and Activity Navigation|Custom ViewMatchers and ViewActions|Best Practices for Writing Robust Espresso Tests" +JUnit,"Introduction to JUnit: Unit Testing Framework|Setting Up JUnit for Local Unit Tests in Android|Writing Basic Test Methods and Assertions|Using Test Fixtures: @Before, @After, @BeforeClass, @AfterClass|Implementing Parameterized Tests|Testing Exceptions and Error Conditions|Organizing Tests with Test Suites and Runners|Integrating JUnit with Mockito for Dependency Mocking" +Distribution,"Introduction to Android App Distribution Channels|Generating Signed APKs and Android App Bundles|Google Play Console Setup and App Listing|Managing Alpha, Beta, and Production Tracks|Internal App Sharing for Quick Testing|Managing App Versions and Updates|Release Management Best Practices|Alternative Distribution Methods (e.g., Sideloading)" +Firebase Distribution,Introduction to Firebase App Distribution|Setting Up Firebase App Distribution in a Project|Distributing Android App Bundles/APKs to Testers|Managing Testers and Tester Groups|Collecting Feedback from Testers|Integrating App Distribution with CI/CD Pipelines|Version Management and Release Notes|Best Practices for Beta Testing with Firebase Distribution +Google Playstore,"Introduction to Google Playstore and its Purpose|Navigating the Playstore and App Discovery|App Categories, Ratings, and Reviews|Google Play Services Integration (e.g., In-app purchases, Games)|Google Play Developer Console Overview|App Publishing Process and Requirements|App Store Optimization (ASO) Strategies|Beta Testing and Staged Rollouts|Policy Compliance and Best Practices" +Signed APK,Understanding APK Files and Their Structure|Introduction to Digital Signatures and Code Signing|Purpose and Importance of Signing APKs|Generating a Keystore and Key Aliases|Signing an APK using Android Studio|Manual APK Signing with Jarsigner|Verifying APK Signatures|Google Play App Signing and Upload Key Management|App Bundles vs. APKs and Their Signing Implications +Interface & Navigation,"Fundamental UI Elements (Buttons, Text Fields, Menus)|Common Navigation Patterns (Tabs, Drawers, Breadcrumbs)|Information Architecture and User Flow Design|Principles of Usability and User Experience (UX)|Responsive Design and Adaptive Interfaces|Accessibility Guidelines (WCAG) and Inclusive Design|Visual Design Principles (Layout, Typography, Color)|Interaction Design and Micro-interactions|Advanced Navigation Patterns (e.g., Wizards, Modals)|Prototyping and User Testing for Interfaces" +Search Engines,"Introduction to Search Engines and Their Purpose|How Search Engines Work: Crawling, Indexing, Ranking|Basic Search Operators and Advanced Search Techniques|Understanding Search Engine Results Pages (SERP)|Search Engine Optimization (SEO) Fundamentals|Keyword Research and Content Optimization|Link Building and Off-Page SEO|Search Engine Algorithms and Updates (e.g., PageRank, BERT)|Specialized Search (Image Search, Voice Search, Local Search)|Measuring Search Performance and Analytics" +Design and Development Principles,"Introduction to Software Design Principles|DRY (Don't Repeat Yourself) and KISS (Keep It Simple, Stupid)|YAGNI (You Ain't Gonna Need It) and Premature Optimization|Separation of Concerns and Modularity|SOLID Principles (Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion)|Design Patterns (Creational, Structural, Behavioral)|Clean Code Practices and Refactoring|Test-Driven Development (TDD) and Behavior-Driven Development (BDD)|Domain-Driven Design (DDD) Fundamentals|Architectural Patterns (MVC, MVVM, Microservices)" +Learn about APIs,"Introduction to APIs: What They Are and Why They're Used|Common API Types (Web APIs, Library APIs, OS APIs)|Understanding HTTP Methods (GET, POST, PUT, DELETE)|RESTful API Principles and Concepts|API Request and Response Formats (JSON, XML)|API Authentication and Authorization Mechanisms (API Keys, OAuth)|Consuming RESTful APIs with Client Libraries|Designing and Documenting RESTful APIs|API Security Best Practices|Introduction to GraphQL and Other API Paradigms" +Internet,"Introduction to the Internet and Its History|How the Internet Works: Basic Infrastructure (Routers, Servers)|IP Addresses, Domain Names, and DNS Resolution|Common Internet Protocols (HTTP, HTTPS, FTP, SMTP)|Client-Server Architecture and Web Browsers|World Wide Web (WWW) vs. Internet|Network Topologies and Connectivity Types (Wi-Fi, Ethernet)|Basic Internet Security (Firewalls, VPNs)|Cloud Computing Fundamentals and Internet of Things (IoT)|Future of the Internet (IPv6, Web3 Concepts)" +PHP,"Introduction to PHP and Server-Side Scripting|PHP Syntax, Variables, and Data Types|Control Structures (Conditionals, Loops)|Functions and Scope in PHP|Working with Arrays and Superglobals|Handling HTML Forms and User Input|Database Interaction with PHP (PDO)|Object-Oriented Programming (OOP) in PHP|Error Handling and Debugging|Introduction to PHP Frameworks (e.g., Laravel, Symfony)" +C#,"Introduction to C# and the .NET Platform|C# Syntax, Variables, and Data Types|Control Flow Statements (If/Else, Loops, Switch)|Functions/Methods and Parameter Passing|Object-Oriented Programming (OOP) Fundamentals|Collections (Arrays, Lists, Dictionaries)|Exception Handling and Debugging|File I/O and Stream Operations|LINQ (Language Integrated Query)|Asynchronous Programming with Async/Await" +Ruby,"Introduction to Ruby and Its Philosophy|Ruby Syntax, Variables, and Data Types|Control Flow (Conditionals, Loops)|Methods, Blocks, Procs, and Lambdas|Object-Oriented Programming (OOP) in Ruby|Classes, Objects, Inheritance, and Mixins|Working with Collections (Arrays, Hashes)|RubyGems and Dependency Management|File I/O and Error Handling|Introduction to Ruby on Rails Framework" +Repo Hosting Services,"Introduction to Version Control and Git Fundamentals|Purpose and Benefits of Repository Hosting Services|Creating and Managing Repositories (e.g., GitHub, GitLab, Bitbucket)|Basic Git Commands (Clone, Commit, Push, Pull)|Branching and Merging Strategies|Collaborative Workflows: Pull Requests/Merge Requests|Code Review Processes and Best Practices|Integrating with CI/CD Pipelines|Repository Security and Access Control|Advanced Features (Wikis, Issues, Project Boards, Webhooks)" +MS SQL,"Introduction to MS SQL Server and Relational Databases|SQL Server Management Studio (SSMS) Overview|Basic SQL Queries (SELECT, FROM, WHERE)|Data Definition Language (DDL): Creating Tables, Data Types|Data Manipulation Language (DML): INSERT, UPDATE, DELETE|Joins (INNER, LEFT, RIGHT, FULL) and Relationships|Subqueries, Common Table Expressions (CTEs), and Views|Stored Procedures, Functions, and Triggers|Indexing Strategies and Performance Tuning|SQL Server Administration and Security" +MariaDB,"Introduction to MariaDB and Relational Database Concepts|Installing and Configuring MariaDB|Basic SQL Commands (SELECT, INSERT, UPDATE, DELETE)|Data Definition Language (DDL): Tables, Data Types, Constraints|Querying Data with WHERE, ORDER BY, GROUP BY|Joins (INNER, LEFT, RIGHT) and Subqueries|Stored Procedures, Functions, and Triggers|User Management and Permissions|Indexing and Query Optimization|Replication and High Availability Concepts" +ORMs,"Introduction to Object-Relational Mapping (ORM)|Benefits and Drawbacks of Using ORMs|Basic Configuration and Database Connection|Mapping Objects to Database Tables (Entities/Models)|Performing CRUD Operations (Create, Read, Update, Delete)|Handling Relationships (One-to-One, One-to-Many, Many-to-Many)|Querying Data with ORM APIs|Transactions and Unit of Work Patterns|Lazy Loading vs. Eager Loading|Performance Considerations and Optimization Techniques" +Normalization,Introduction to Database Normalization and Its Purpose|Understanding Data Redundancy and Anomalies|Functional Dependencies and Primary Keys|First Normal Form (1NF) Principles|Second Normal Form (2NF) Principles|Third Normal Form (3NF) Principles|Boyce-Codd Normal Form (BCNF)|Fourth Normal Form (4NF) and Fifth Normal Form (5NF)|Denormalization Strategies and When to Apply Them|Practical Application of Normalization in Database Design +ACID,"Introduction to Database Transactions|Understanding the ACID Properties Overview|Atomicity: All or Nothing Principle|Consistency: Maintaining Data Integrity|Isolation: Concurrency Control and Transaction Anomalies|Durability: Ensuring Data Persistence|Implementing Transactions in SQL|Concurrency Control Mechanisms (Locking, MVCC)|Trade-offs in Distributed Systems (BASE vs. ACID)|Practical Implications of ACID in Database Design" +Failure Modes,"Introduction to System Failures and Their Impact|Common Software Failure Modes (Bugs, Crashes, Deadlocks)|Hardware Failure Modes (Disk Failure, Power Outage, Network Issues)|Data Corruption and Loss Scenarios|Distributed System Failure Modes (Network Partitions, Node Failures)|Understanding Single Points of Failure|Error Handling and Graceful Degradation|Fault Tolerance and Redundancy Strategies|Disaster Recovery Planning and Business Continuity|Resilience Engineering and Chaos Engineering" +Profiling Perfor.,"Introduction to Performance Profiling and Its Importance|Identifying Performance Bottlenecks|Basic Profiling Tools and Techniques (e.g., Task Manager, `top`)|CPU Profiling: Understanding CPU Usage and Hotspots|Memory Profiling: Detecting Leaks and Excessive Allocation|I/O Profiling: Analyzing Disk and Network Operations|Database Query Profiling and Optimization|Web Application Performance Profiling (Browser DevTools)|Distributed Tracing and Observability|Interpreting Profiling Results and Optimization Strategies" +N+1 Problem,Introduction to the N+1 Query Problem|Understanding the Performance Impact of N+1|Illustrative Examples in Database Queries|How N+1 Arises in Object-Relational Mappers (ORMs)|Identifying N+1 Problems in Code|Eager Loading / Preloading as a Solution|Batching Queries and Joins to Mitigate N+1|Caching Strategies to Reduce Database Hits|Tools and Techniques for Detecting N+1 Issues|Best Practices for Efficient Data Retrieval +More about Databases,"Overview of Database Systems and Their Evolution|Relational vs. Non-Relational (NoSQL) Databases|Database Architecture Components (Storage Engine, Query Processor)|Data Modeling Techniques (ER Diagrams, Schema Design)|Database Security: Access Control, Encryption, Auditing|Backup and Recovery Strategies|Concurrency Control and Transaction Management|Distributed Databases and Sharding|Introduction to NoSQL Databases (Key-Value, Document, Column-Family, Graph)|Data Warehousing, OLAP, and Big Data Concepts" +Database Indexes,"Introduction to Database Indexes|Types of Indexes (B-Tree, Hash, Full-Text)|Index Creation and Management|Clustered vs. Non-Clustered Indexes|Composite Indexes and Index Selectivity|Index Performance Optimization with Query Plans|Indexing Strategies for Different Workloads" +Sharding Strategies,Introduction to Database Sharding|Sharding Key Selection and Considerations|Range-Based Sharding Implementation|Hash-Based Sharding Techniques|Directory-Based Sharding Architectures|Resharding and Data Migration Challenges|Sharding in Distributed Database Systems +Data Replication,"Introduction to Data Replication Concepts|Types of Replication (Master-Slave, Master-Master)|Synchronous vs. Asynchronous Replication|Replication Topologies and Architectures|Conflict Resolution in Multi-Master Replication|Log-Based Replication Mechanisms|Replication for High Availability and Disaster Recovery" +CAP Theorem,"Introduction to Distributed Systems Challenges|Defining Consistency, Availability, and Partition Tolerance|Understanding the 'Choose Two' Constraint|Implications for Database Design (CP vs. AP Systems)|Examples of CP Systems and Their Trade-offs|Examples of AP Systems and Eventual Consistency|Practical Trade-offs in Real-World Distributed Systems" +Scaling Databases,Introduction to Database Scaling Challenges|Vertical Scaling (Scale Up) Techniques|Horizontal Scaling (Scale Out) Principles|Read Replicas and Load Balancing for Databases|Database Connection Pooling Optimization|Caching Strategies for Database Performance|Sharding and Partitioning for Scalability|Leveraging NoSQL Databases for Scalability +HATEOAS,Introduction to REST Principles and Constraints|Understanding Hypermedia as the Engine of Application State|Linking Resources in API Responses|Designing Discoverable APIs with HATEOAS|Media Types and Link Relations in HATEOAS|Implementing HATEOAS with Frameworks|Benefits and Drawbacks of HATEOAS Adoption +JSON APIs,"Introduction to APIs and Web Services|JSON Syntax and Data Types|HTTP Methods for API Interactions (GET, POST, PUT, DELETE)|Designing RESTful JSON API Endpoints|Request and Response Structure (Headers, Body, Status Codes)|Authentication and Authorization for JSON APIs|Error Handling and Standardized Response Formats|Versioning Strategies for JSON APIs|Tools for Testing and Documenting JSON APIs" +Open API Specs,"Introduction to API Documentation Standards|Understanding the OpenAPI Specification (OAS)|YAML and JSON Syntax for OpenAPI Definitions|Defining API Endpoints, Parameters, and Responses|Describing Data Models with OpenAPI Schemas|Authentication and Security Definitions in OpenAPI|Generating API Documentation (e.g., Swagger UI)|Code Generation from OpenAPI Specifications" +gRPC,"Introduction to Remote Procedure Calls (RPC)|Protocol Buffers (Protobuf) for Data Serialization|Defining Services and Messages in Protobuf|gRPC Communication Patterns (Unary, Streaming)|gRPC Channels and Stubs|Error Handling and Metadata in gRPC|Interceptors for gRPC Services|Load Balancing and Health Checks for gRPC|Comparison of gRPC with REST APIs" +Client Side,"Introduction to Web Architecture and Client-Server Model|HTML Structure and Semantic Elements|CSS Styling, Layout, and Responsive Design|JavaScript Fundamentals and DOM Manipulation|Asynchronous JavaScript (Promises, Async/Await)|Front-end Frameworks (e.g., React, Vue, Angular)|Client-Side Routing and State Management|Browser Storage Mechanisms (Local Storage, Session Storage)|Performance Optimization and Web Vitals" +CDN,"Introduction to Content Delivery Networks (CDNs)|How CDNs Work (Edge Servers, Caching, DNS)|Types of Content Delivered by CDNs|CDN Configuration and Cache Invalidation Strategies|Geographic Load Balancing and Routing|Security Features of CDNs (DDoS Protection, WAF)|Performance Monitoring and Analytics for CDNs|Choosing and Integrating a CDN Provider" +Server Side,"Introduction to Server-Side Architecture|Server-Side Programming Languages and Frameworks|Web Servers (e.g., Nginx, Apache) and Their Role|HTTP Request-Response Cycle|Routing and Middleware in Server Applications|Database Interactions and ORMs|Authentication and Authorization on the Server|API Design and Implementation on the Server|Deployment and Scaling Server-Side Applications" +Caching,"Introduction to Caching Concepts and Benefits|Types of Caching (Browser, CDN, Application, Database)|Cache Invalidation Strategies|Cache-Aside Pattern Implementation|Read-Through and Write-Through Caching|Distributed Caching Systems (e.g., Redis, Memcached)|Cache Coherency and Consistency Issues|Monitoring and Optimizing Cache Performance" +Web Security,"Introduction to Web Security Threats and Principles|Authentication and Authorization Mechanisms|Cross-Site Scripting (XSS) Prevention|Cross-Site Request Forgery (CSRF) Prevention|SQL Injection Prevention Techniques|Secure Communication with HTTPS and TLS|Input Validation and Output Encoding|Security Headers (CSP, HSTS, X-Frame-Options)|OWASP Top 10 Vulnerabilities" +Integration Testing,"Introduction to Software Testing Levels|Purpose and Scope of Integration Testing|Types of Integration Testing Approaches|Test Doubles (Stubs, Mocks, Spies) for Dependencies|Setting Up Test Environments for Integration Tests|Writing Integration Tests for APIs and Database Interactions|Continuous Integration and Integration Testing|Tools and Frameworks for Integration Testing" +Functional Testing,"Introduction to Functional vs. Non-Functional Testing|Purpose and Scope of Functional Testing|Test Case Design Techniques (Equivalence Partitioning, BVA)|Black-Box Testing Principles|User Acceptance Testing (UAT)|End-to-End Testing Methodologies|Automated Functional Testing Frameworks (e.g., Selenium, Cypress)|Test Data Management for Functional Tests|Reporting and Analyzing Functional Test Results" +GOF Design Patterns,"Introduction to Software Design Principles (SOLID)|Purpose and Benefits of Design Patterns|Creational Design Patterns (Singleton, Factory, Builder)|Structural Design Patterns (Adapter, Decorator, Facade)|Behavioral Design Patterns (Observer, Strategy, Command)|Anti-Patterns and When to Avoid Patterns|Refactoring to Design Patterns|Design Patterns in Modern Frameworks and Libraries" +CQRS,"Introduction to Command Query Responsibility Segregation|Understanding Commands and Queries|Separating Read and Write Models|Eventual Consistency in CQRS Architectures|Data Synchronization Strategies (e.g., Event Bus, Message Queues)|Benefits and Drawbacks of CQRS Adoption|When to Apply CQRS in Complex Domains|Implementing CQRS with Event Sourcing (Optional)" +Domain Driven Design,"Introduction to Domain-Driven Design Principles|Ubiquitous Language and Bounded Contexts|Entities, Value Objects, and Aggregates|Domain Services and Application Services|Repositories for Data Persistence|Domain Events and Event Storming|Strategic Design (Context Mapping, Shared Kernel)|Tactical Design Patterns in DDD|Implementing DDD in Practice" +Event Sourcing,"Introduction to Event-Driven Architectures|Understanding Event Sourcing Principles|Event Store and Event Stream|Aggregates and Event Handlers|Rebuilding State from Events (Projections)|Benefits of Event Sourcing (Auditability, Debugging)|Challenges of Event Sourcing (Complexity, Event Versioning)|Integrating Event Sourcing with CQRS|Tools and Frameworks for Event Sourcing" +Test Driven Development,Introduction to TDD Principles|Red-Green-Refactor Cycle|Writing Unit Tests and Assertions|Mocking and Stubbing Dependencies|Integration Testing in TDD|Acceptance Testing and BDD Concepts|TDD Best Practices and Pitfalls +Monolithic Apps,Definition and Characteristics of Monoliths|Advantages of Monolithic Architecture|Disadvantages and Challenges of Monoliths|Scaling Strategies for Monolithic Applications|Database Management in Monolithic Systems|Deployment and Release Management for Monoliths|Strategies for Decomposing Monoliths +Serverless,"Introduction to Serverless Computing Concepts|Functions as a Service (FaaS) Principles|Event-Driven Architectures in Serverless|Serverless Data Storage Options (e.g., DynamoDB, S3)|Serverless API Gateways and Endpoints|Monitoring and Debugging Serverless Applications|Serverless Security Best Practices|Cost Management in Serverless Architectures" +Service Mesh,"Introduction to Microservices Challenges|Definition and Purpose of a Service Mesh|Sidecar Proxy Pattern|Traffic Management (Routing, Load Balancing)|Observability (Metrics, Tracing, Logging)|Security (mTLS, Authorization Policies)|Fault Injection and Resilience Patterns|Popular Service Mesh Implementations (e.g., Istio, Linkerd)" +SOA,"Introduction to Distributed Systems Concepts|Principles and Characteristics of SOA|Services, Contracts, and Loose Coupling|Enterprise Service Bus (ESB) Role|Service Discovery and Registry|Orchestration vs. Choreography|SOA Governance and Management|Transitioning from Monoliths to SOA" +Twelve Factor Apps,"Introduction to Cloud-Native Principles|Codebase: One Codebase, Many Deploys|Dependencies: Explicitly Declare and Isolate|Config: Store Config in the Environment|Backing Services: Treat as Attached Resources|Build, Release, Run: Strictly Separate Stages|Processes: Execute as One or More Stateless Processes|Port Binding: Export Services via Port Binding|Concurrency: Scale Out via the Process Model|Disposability: Maximize Robustness with Fast Startup and Graceful Shutdown|Dev/Prod Parity: Keep Development, Staging, and Production as Similar as Possible|Logs: Treat Logs as Event Streams|Admin Processes: Run Admin/Management Tasks as One-Off Processes" +RabbitMQ,"Introduction to Message Queues and AMQP|RabbitMQ Architecture and Components (Exchanges, Queues, Bindings)|Publishers and Consumers|Message Durability and Persistence|Message Acknowledgments and Reliability|Routing and Exchange Types (Direct, Fanout, Topic, Headers)|Clustering and High Availability|Monitoring and Management with RabbitMQ Management Plugin" +Message Brokers,"Introduction to Asynchronous Communication|Purpose and Benefits of Message Brokers|Core Concepts: Producers, Consumers, Queues, Topics|Message Patterns: Point-to-Point vs. Publish/Subscribe|Message Durability and Reliability|Message Ordering and Dead Letter Queues|Comparison of Popular Message Brokers (e.g., RabbitMQ, Kafka, ActiveMQ)|Use Cases and Anti-Patterns for Message Brokers" +LXC,"Introduction to Linux Kernel Features (cgroups, namespaces)|LXC Architecture and Components|Creating and Managing LXC Containers|Networking for LXC Containers|Storage Management in LXC|LXC Security Considerations|Comparison of LXC with Docker and VMs" +Containerization vs Virtualization,"Introduction to Virtualization Technology (Hypervisors, VMs)|Understanding Containerization Principles|Key Differences: OS Sharing, Resource Isolation|Performance and Resource Utilization Comparison|Deployment and Portability Aspects|Security Implications of Each Approach|Use Cases for Virtualization|Use Cases for Containerization|Hybrid Approaches and Orchestration" +WebSockets,Introduction to HTTP Limitations for Real-time|WebSocket Protocol Handshake|Full-Duplex Communication Model|Sending and Receiving Data over WebSockets|Error Handling and Connection Management|WebSocket Security Considerations|Building Real-time Applications with WebSockets|Comparison with Polling and Server-Sent Events +Server Sent Events,Introduction to Unidirectional Real-time Communication|SSE Protocol and Event Stream Format|Establishing an SSE Connection|Sending Data from Server to Client|Automatic Reconnection Mechanism|Error Handling and Connection Management|Use Cases for Server-Sent Events|Comparison with WebSockets and Long Polling +Nginx,Introduction to Web Servers and Reverse Proxies|Nginx Installation and Basic Configuration|Serving Static Content|Reverse Proxying and Load Balancing|Virtual Hosts and Server Blocks|SSL/TLS Configuration|Caching with Nginx|Security Best Practices for Nginx|Performance Tuning Nginx +Caddy,Introduction to Caddy Web Server Features|Automatic HTTPS with Let's Encrypt|Caddyfile Syntax and Configuration|Serving Static Files|Reverse Proxying and Load Balancing|Dynamic Configuration with Caddy API|Middleware and Plugins|Security Features of Caddy +Apache,Introduction to Apache HTTP Server|Installation and Basic Configuration (httpd.conf)|Serving Static Content|Virtual Hosts Configuration|Modules and Dynamic Loading|URL Rewriting with mod_rewrite|SSL/TLS Configuration|Access Control and Authentication|Performance Tuning Apache +MS IIS,Introduction to IIS Architecture and Components|Installation and Management Tools (IIS Manager)|Creating and Configuring Websites|Application Pools and Worker Processes|Authentication and Authorization in IIS|SSL/TLS Configuration|URL Rewriting and Request Filtering|Logging and Monitoring IIS|Deployment of ASP.NET Applications on IIS +Web Servers,"Fundamental Role of Web Servers|HTTP Protocol Basics|Static vs. Dynamic Content Serving|Reverse Proxying and Load Balancing Concepts|Caching Mechanisms|SSL/TLS and Security Considerations|Common Web Server Features (e.g., Virtual Hosts, Logging)|Comparison of Popular Web Servers (e.g., Apache, Nginx, IIS, Caddy)" +Building For Scale,"Introduction to Scalability Concepts (Vertical vs. Horizontal)|Stateless Application Design|Load Balancing Strategies|Database Scaling Techniques (Sharding, Replication)|Caching Strategies (Client-side, Server-side, CDN)|Asynchronous Processing and Message Queues|Microservices Architecture for Scalability|Monitoring and Performance Metrics|Resilience and Fault Tolerance" +Memcached,"Introduction to Caching Concepts|Memcached Architecture and Data Model|Key-Value Store Operations (Set, Get, Delete)|Cache Eviction Policies (LRU)|Distributed Caching with Memcached|Integration with Application Frameworks|Monitoring Memcached Performance|Common Use Cases and Anti-Patterns" +MongoDB,"Introduction to NoSQL Databases|MongoDB Document Model and BSON|Basic CRUD Operations (Create, Read, Update, Delete)|Indexing for Performance|Aggregation Framework|Replication for High Availability|Sharding for Horizontal Scalability|Schema Design Best Practices|MongoDB Security Features" +CouchDB,"Introduction to NoSQL and Document Databases|CouchDB Architecture and Core Concepts (Documents, Revisions, MVCC)|CRUD Operations with HTTP API|Views (MapReduce) and Querying Data|Replication and Synchronization|Security and Authentication|Attachments and Binary Data" +Neo4j,"Introduction to Graph Databases and Use Cases|Graph Data Model (Nodes, Relationships, Properties)|Cypher Query Language Fundamentals|Creating and Manipulating Graph Data|Querying and Pattern Matching with Cypher|Indexing and Performance Optimization|Graph Algorithms (e.g., Pathfinding, Centrality)|Transactions and Concurrency" +Graceful Degradation,"Definition and Principles of Graceful Degradation|Distinction from Fault Tolerance and High Availability|Identifying Critical vs. Non-Critical Features|Strategies for Feature Prioritization|Implementation Techniques (e.g., Feature Flags, Fallbacks)|User Experience Considerations during Degradation|Monitoring and Alerting for Degraded States" +Throttling,"Definition and Purpose of Throttling|Common Use Cases (API Rate Limiting, Resource Control)|Throttling Algorithms (e.g., Leaky Bucket, Token Bucket)|Implementing Server-Side Throttling|Client-Side Throttling and Backoff Strategies|Impact on System Performance and User Experience|Monitoring Throttling Effectiveness" +Backpressure,"Understanding Backpressure in Distributed Systems|Causes and Symptoms of Backpressure|Reactive Streams and Backpressure Principles|Strategies for Applying Backpressure (e.g., Bounded Queues, Flow Control)|Impact on System Stability and Throughput|Implementing Backpressure in Producers and Consumers|Monitoring and Tuning Backpressure Mechanisms" +Loadshifting,Definition and Goals of Loadshifting|Identifying Peak vs. Off-Peak Periods|Strategies for Deferring Workloads|Batch Processing and Asynchronous Tasks|Geographic Loadshifting and CDN Utilization|Impact on Resource Utilization and Cost|Monitoring and Optimizing Loadshifting Effectiveness +Circuit Breaker,"Introduction to the Circuit Breaker Pattern|Problem Solved: Preventing Cascading Failures|States of a Circuit Breaker (Closed, Open, Half-Open)|Implementation Details (Failure Thresholds, Reset Timers)|Integrating Circuit Breakers into Microservices|Monitoring Circuit Breaker State|Testing Circuit Breaker Behavior" +Migration Strategies,"Understanding the Need for Migration|Types of Migrations (Data, Application, Infrastructure)|Common Migration Patterns (e.g., Big Bang, Strangler Fig)|Planning and Assessment Phases|Data Migration Techniques (ETL, Replication, Dual Write)|Application Compatibility and Testing|Rollback Planning and Disaster Recovery|Monitoring and Validation Post-Migration" +Types of Scaling,"Definition of Scaling and its Importance|Vertical Scaling (Scale Up) vs. Horizontal Scaling (Scale Out)|Stateless vs. Stateful Applications in Scaling|Database Scaling Strategies (Sharding, Replication)|Load Balancing and Distribution|Auto-Scaling Mechanisms (e.g., Cloud Auto Scaling Groups)|Performance Metrics for Scaling Decisions" +Instrumentation,"Definition and Purpose of Instrumentation|Types of Data Collected (Metrics, Logs, Traces)|Choosing Instrumentation Libraries and Frameworks|Adding Custom Metrics to Applications|Structured Logging Best Practices|Distributed Tracing Concepts and Implementation|Integrating with Monitoring Systems" +Monitoring,"Definition and Importance of System Monitoring|Key Monitoring Metrics (CPU, Memory, Disk I/O, Network)|Application Performance Monitoring (APM)|Log Aggregation and Analysis|Alerting Strategies and On-Call Rotations|Dashboard Design and Visualization|Defining Service Level Objectives (SLOs) and Service Level Indicators (SLIs)" +MD5,"Introduction to Cryptographic Hash Functions|MD5 Algorithm Overview and History|Properties of MD5 (Fixed Output Size, One-Way)|Common Use Cases (File Integrity Check, Data Verification)|MD5 Collisions and Security Weaknesses|Why MD5 is Not Suitable for Password Hashing" +SHA,"Introduction to the Secure Hash Algorithm (SHA) Family|SHA-1 Overview and its Deprecation|SHA-2 Family (SHA-256, SHA-512) and their Properties|SHA-3 Family (Keccak) and its Design Principles|Common Use Cases (Digital Signatures, Certificates, Password Hashing)|Choosing the Right SHA Variant for Security Needs" +scrypt,"Introduction to Key Derivation Functions (KDFs)|Problem Solved: Protecting Against Brute-Force Attacks|scrypt Algorithm Design Principles (Memory-Hardness, CPU-Hardness)|Parameters of scrypt (N, r, p) and their Impact|Salting and Iteration Count for Password Hashing|Implementing scrypt for Password Storage|Security Best Practices for Password Hashing" +bcrypt,"Introduction to Adaptive Hash Functions|bcrypt Algorithm Design Principles (Blowfish-based, Work Factor)|Understanding the Cost Factor (Rounds)|Salting for Password Hashing|Implementing bcrypt for Password Storage|Security Considerations and Best Practices|Comparison with Other Password Hashing Algorithms" +HTTPS,"Introduction to HTTP and its Limitations|Purpose and Benefits of HTTPS (Confidentiality, Integrity, Authentication)|How HTTPS Works: Overview of TLS Handshake|Public Key Infrastructure (PKI) and Certificates|Certificate Authorities (CAs) and Trust Chains|HTTP Strict Transport Security (HSTS)|Troubleshooting HTTPS Connections" +OWASP Risks,"Introduction to Web Application Security|Overview of OWASP Top 10 Project|Understanding Injection Flaws (SQL, Command)|Broken Authentication and Session Management|Sensitive Data Exposure|Broken Access Control|Cross-Site Scripting (XSS)|Security Misconfiguration|Using Components with Known Vulnerabilities|Insufficient Logging & Monitoring" +SSL/TLS,Introduction to Cryptographic Protocols|Evolution from SSL to TLS Versions|TLS Handshake Process and Key Exchange|Symmetric vs. Asymmetric Encryption in TLS|Digital Certificates and Certificate Authorities|Cipher Suites and Protocol Negotiation|Common TLS Vulnerabilities and Best Practices|Client and Server-Side TLS Configuration +CORS,"Understanding the Same-Origin Policy (SOP)|Purpose and Necessity of Cross-Origin Resource Sharing (CORS)|Simple Requests vs. Preflighted Requests|CORS Headers (Origin, Access-Control-Allow-Origin, Methods, Headers)|Implementing CORS on the Server-Side|CORS in Modern Web Frameworks|Troubleshooting CORS Errors|Security Implications of Misconfigured CORS" +Server Security,"Fundamentals of Server Hardening|Operating System Security Best Practices|Network Security (Firewalls, VPNs, Segmentation)|Access Control and Least Privilege Principles|Patch Management and Vulnerability Scanning|Logging, Auditing, and Intrusion Detection|Secure Configuration of Web Servers and Databases|Container and Virtualization Security|Incident Response Planning" +CSP,"Introduction to Content Security Policy (CSP)|CSP Directives: script-src, style-src, default-src|CSP Source Expressions: 'self', 'unsafe-inline', 'unsafe-eval', data:|Implementing CSP: HTTP Header vs. Meta Tag|CSP Reporting: report-uri and report-to|Advanced CSP: nonces and hashes for inline scripts/styles|CSP for WebSockets and Web Workers|CSP Bypass Techniques and Best Practices" +How does the internet work?,"Introduction to Networks: Nodes, Links, and Packets|IP Addresses and MAC Addresses|Routers, Switches, and Modems|The OSI Model and TCP/IP Model Overview|Domain Name System (DNS) Basics|Client-Server Architecture|Common Internet Protocols: HTTP, HTTPS, FTP, SMTP|Internet Service Providers (ISPs) and Backbone Infrastructure|How Data Travels Across the Internet" +What is HTTP?,"Introduction to HTTP: Client-Server Model|HTTP Request Methods: GET, POST, PUT, DELETE|HTTP Status Codes: 2xx, 3xx, 4xx, 5xx|HTTP Headers: Request and Response Headers|HTTP Message Structure: Request Line, Headers, Body|HTTP Statelessness and Session Management Basics|HTTP/1.1 vs. HTTP/2 vs. HTTP/3 Overview|HTTPS: HTTP Secure and TLS/SSL Encryption|HTTP Caching Mechanisms" +What is Domain Name?,Introduction to Domain Names and their Purpose|Domain Name Structure: Top-Level Domains (TLDs) and Second-Level Domains (SLDs)|Subdomains and their Usage|Domain Name Registration Process|Domain Name System (DNS) and Domain Names Relationship|Internationalized Domain Names (IDNs)|Domain Name Management and Renewal|Domain Name Privacy and Security Considerations +What is hosting?,"Introduction to Web Hosting: Purpose and Necessity|Types of Hosting: Shared Hosting, VPS Hosting, Dedicated Hosting|Cloud Hosting and its Benefits|Content Delivery Networks (CDNs) for Performance|Domain Name System (DNS) Configuration for Hosting|Website Deployment and File Transfer Protocols (FTP/SFTP)|Database Hosting and Management|Scalability and High Availability in Hosting|Security Best Practices for Web Hosting" +DNS and how it works?,"Introduction to DNS: The Internet's Phonebook|DNS Hierarchy: Root, TLD, Authoritative Name Servers|DNS Records: A, AAAA, CNAME, MX, TXT, NS|The DNS Resolution Process: Recursive and Iterative Queries|DNS Caching Mechanisms|DNS Zones and Zone Files|DNS Security Extensions (DNSSEC)|DNS Management Tools and Providers|Troubleshooting DNS Issues" +Browsers and how they work?,"Introduction to Web Browsers and their Core Function|Browser User Interface Components|The Browser's Request-Response Cycle|Rendering Engine: HTML Parsing, CSS Styling, Layout, and Painting|JavaScript Engine: Execution and the Event Loop|Browser Storage Mechanisms: Cookies, Local Storage, Session Storage|Browser Security Models: Same-Origin Policy, Sandboxing|Browser Developer Tools for Debugging and Performance|Web APIs and Browser Extensions" +JWT,"Introduction to JSON Web Tokens (JWT) and their Purpose|JWT Structure: Header, Payload, Signature|JWT Claims: Registered, Public, and Private Claims|Signing and Verifying JWTs (HMAC, RSA, ECDSA)|Using JWTs for Authentication and Authorization|Statelessness and Scalability with JWTs|JWT Security Considerations: Storage, Expiration, Revocation|Refresh Tokens and Access Token Management|Implementing JWTs in Web Applications" +Basic Authentication,"Introduction to HTTP Basic Authentication|How Basic Authentication Works: Request Header and Base64 Encoding|User Credentials and Server-Side Verification|Security Implications and Vulnerabilities of Basic Auth (lack of encryption)|When to Use and When to Avoid Basic Authentication|Implementing Basic Authentication in Web Servers (e.g., Apache, Nginx)|Client-Side Handling of Basic Authentication|Comparison with other Authentication Methods" +Token Authentication,"Introduction to Token-Based Authentication Principles|Types of Tokens: Access Tokens, Refresh Tokens, ID Tokens|Token Issuance and Client-Side Storage|Token Validation and Server-Side Verification|Statelessness and Scalability Benefits of Tokens|Token Expiration and Renewal Strategies|Security Considerations for Token Authentication (CSRF, XSS)|Comparison with Session-Based Authentication|Implementing Token Authentication Flows (e.g., OAuth 2.0, JWT-based)" +Cookie Based Auth,"Introduction to Cookie-Based Authentication and Sessions|How HTTP Cookies Work: Set-Cookie Header|Session IDs and Server-Side Session Storage|Cookie Attributes: HttpOnly, Secure, SameSite, Expires/Max-Age|Session Management and Expiration|Security Vulnerabilities: Cross-Site Request Forgery (CSRF)|Security Vulnerabilities: Cross-Site Scripting (XSS) and Cookie Theft|Implementing CSRF Protection (Tokens)|Scaling Session-Based Authentication (Distributed Sessions)" +OpenID,Introduction to OpenID and Decentralized Identity|OpenID vs. OpenID Connect (OIDC)|OpenID Providers (OP) and Relying Parties (RP)|The OpenID Connect Authentication Flow (Authorization Code Flow)|ID Tokens and User Information Claims|Scopes and Consent in OIDC|Client Registration and Configuration|Security Considerations in OpenID Connect|Implementing OpenID Connect in Applications +SAML,"Introduction to SAML (Security Assertion Markup Language)|SAML Use Cases: Single Sign-On (SSO)|SAML Roles: Identity Provider (IdP) and Service Provider (SP)|SAML Assertions: Authentication, Attribute, Authorization Decision|SAML Bindings: HTTP Redirect, HTTP POST, SOAP|SAML Profiles: Web Browser SSO Profile|SAML Metadata and Configuration|SAML Security Considerations: Digital Signatures, Encryption|Implementing SAML in Enterprise Applications" +Solr,"Introduction to Solr and its Core Concepts|Solr Architecture: Cores, Collections, Nodes|Indexing Data into Solr: Documents, Fields, Data Import Handler (DIH)|Solr Schema Design: Managed Schema, Schema API, Field Types|Basic Solr Querying: Q Syntax, Filters, Sorting|Advanced Solr Querying: Faceting, Highlighting, Grouping|SolrCloud: Distributed Indexing and Searching|Relevance Tuning and Custom Scoring|Solr Security and Performance Optimization" +Real-Time Data,"Introduction to Real-Time Data and its Importance|Use Cases for Real-Time Data (e.g., Chat, IoT, Analytics)|Challenges of Real-Time Data Processing|Polling Mechanisms: Short Polling vs. Long Polling|WebSockets for Bidirectional Communication|Server-Sent Events (SSE) for Unidirectional Streams|Message Queues and Stream Processing (e.g., Kafka, RabbitMQ)|Real-Time Databases and Data Stores|Designing and Implementing Real-Time Data Architectures" +Long Polling,"Introduction to Polling and its Limitations|Understanding Short Polling vs. Long Polling|How Long Polling Works: Server Holds Connection|Use Cases for Long Polling (e.g., Chat, Notifications)|Implementing Long Polling on the Server-Side|Client-Side Implementation and Reconnection Logic|Advantages and Disadvantages of Long Polling|Scalability Challenges and Solutions for Long Polling|Comparison with WebSockets and Server-Sent Events" +Short Polling,"Introduction to Polling and its Basic Concept|How Short Polling Works: Periodic Requests|Implementing Short Polling on the Client-Side (JavaScript setInterval)|Use Cases for Short Polling (e.g., Infrequent Updates)|Performance Implications: Network Overhead and Server Load|Determining Optimal Polling Intervals|Advantages and Disadvantages of Short Polling|Comparison with Long Polling and Push Technologies|When to Choose Short Polling vs. Other Real-Time Methods" +DynamoDB,"Introduction to Amazon DynamoDB and NoSQL Concepts|DynamoDB Core Components: Tables, Items, Attributes|Primary Keys: Partition Key and Sort Key Design|Data Types and Schemaless Nature|Basic Operations: PutItem, GetItem, UpdateItem, DeleteItem|Querying and Scanning Data|Global Secondary Indexes (GSIs) and Local Secondary Indexes (LSIs)|DynamoDB Streams for Change Data Capture|DynamoDB Accelerator (DAX) for Caching and Performance|Provisioned Throughput vs. On-Demand Capacity" +Firebase,"Introduction to Firebase and its Ecosystem|Setting up a Firebase Project and SDK Integration|Firebase Authentication: Email/Password, Social Logins|Cloud Firestore: NoSQL Document Database (Data Modeling, Queries)|Firebase Realtime Database: JSON Tree Database (Data Sync)|Firebase Hosting: Deploying Web Applications|Cloud Functions for Firebase: Serverless Backend Logic|Firebase Storage: File Uploads and Downloads|Firebase Security Rules for Firestore and Realtime Database|Firebase Extensions and Integrations" +RethinkDB,"Introduction to RethinkDB and its Real-Time Capabilities|RethinkDB Data Model: Documents, Tables, Databases|RethinkDB Query Language (ReQL) Basics|CRUD Operations with ReQL|Real-Time Changefeeds: Subscribing to Data Changes|Indexing and Query Optimization|Clustering and Sharding for Scalability|Data Durability and Replication|Integrating RethinkDB with Web Applications|RethinkDB Administration and Monitoring" +Influx DB,"Introduction to Time-Series Data and Databases|InfluxDB Architecture and Core Concepts (Points, Series, Buckets)|Data Ingestion with Telegraf and Client Libraries|Querying Data with InfluxQL and Flux Language|Data Visualization with Chronograf and Grafana|Data Retention Policies and Downsampling|High Availability and Clustering|Security and Authentication" +TimeScale,Introduction to PostgreSQL and Relational Databases|Time-Series Data Concepts and Challenges|TimescaleDB Installation and Setup|Hypertable Creation and Chunking|Data Ingestion and Querying with SQL|Continuous Aggregates and Materialized Views|Data Retention Policies and Compression|High Availability and Backup Strategies +Base,"Introduction to Data and Information Systems|Database Management Systems (DBMS) Overview|Data Models (Relational, NoSQL, Graph)|Database Schema Design Principles|CRUD Operations (Create, Read, Update, Delete)|Indexing and Query Optimization Basics|Data Integrity and Constraints|Backup and Recovery Fundamentals" +AWS Neptune,"Introduction to Graph Databases and Use Cases|Graph Data Models (Property Graph, RDF)|AWS Neptune Service Overview and Architecture|Creating and Managing Neptune Clusters|Data Loading and Ingestion Strategies|Querying with Gremlin and SPARQL|Graph Traversal and Pattern Matching|Performance Tuning and Optimization" +What is Product Management?,"Definition and Core Principles of Product Management|The Role of a Product Manager in an Organization|Key Responsibilities and Accountabilities|Product Management vs. Project Management (High-Level)|Importance of User Empathy and Market Understanding|Product Vision and Strategy Basics|Introduction to Product Lifecycle|Common Product Management Methodologies (Agile, Lean)" +Product vs Project Management,Defining Product Management Scope and Objectives|Defining Project Management Scope and Objectives|Key Differences in Focus: Outcome vs. Output|Differences in Time Horizon and Strategy|Stakeholder Management in Product vs. Project|Decision-Making Authority and Responsibilities|Collaboration and Overlap Between Roles|When to Use Product vs. Project Approaches +Roles and Responsibilities,"Understanding the Product Manager's Core Mandate|Market Research and User Understanding|Product Strategy and Roadmap Development|Feature Prioritization and Backlog Management|Cross-Functional Team Collaboration (Engineering, Design, Marketing)|Stakeholder Communication and Alignment|Product Launch and Go-to-Market Strategy|Performance Monitoring and Iteration" +Key Skills,Strategic Thinking and Business Acumen|Communication and Presentation Skills|User Empathy and Design Thinking|Data Analysis and Decision Making|Technical Understanding (without being an engineer)|Prioritization and Time Management|Negotiation and Influence|Problem Solving and Critical Thinking +Product Development Lifecycle,Introduction to the Product Development Process|Idea Generation and Discovery Phase|Validation and Feasibility Analysis|Design and Prototyping|Development and Implementation|Testing and Quality Assurance|Launch and Deployment|Post-Launch Monitoring and Iteration +Development,"Software Development Methodologies (Agile, Scrum, Kanban)|Technical Design and Architecture Principles|Coding Standards and Best Practices|Version Control Systems (Git)|Continuous Integration and Continuous Delivery (CI/CD)|Unit, Integration, and System Testing|Debugging and Troubleshooting Techniques|Deployment Strategies and Environments" +Introduction,Defining the Product Introduction Phase|Market Entry Strategies|Initial Marketing and Awareness Campaigns|Early Adopter Targeting and Feedback Collection|Minimum Viable Product (MVP) Concepts|Establishing Product-Market Fit|Initial Sales and Distribution Channels|Monitoring Key Performance Indicators (KPIs) for Introduction +Growth,Characteristics of the Product Growth Phase|Scaling Marketing and Sales Efforts|Expanding Distribution Channels|Feature Enhancement and Product Iteration|Competitive Analysis and Differentiation|Customer Acquisition and Retention Strategies|Managing Rapid User Base Expansion|Optimizing for Scalability and Performance +Maturity,"Defining the Product Maturity Phase|Market Saturation and Intense Competition|Focus on Cost Optimization and Efficiency|Customer Retention and Loyalty Programs|Product Differentiation and Niche Targeting|Incremental Innovation and Feature Refinements|Pricing Strategies in a Mature Market|Extending Product Life (e.g., new use cases, bundles)" +Decline,"Characteristics of the Product Decline Phase|Reasons for Product Decline (e.g., obsolescence, new tech)|Strategies for Managing Decline (Harvesting, Divestment)|Reducing Costs and Streamlining Operations|Customer Support and End-of-Life Communications|Migration Strategies for Existing Users|Analyzing Lessons Learned from Product Failure|Resource Allocation for New Product Development" +Mind Mapping,"Introduction to Mind Mapping Concepts|Core Principles and Benefits of Mind Mapping|Tools and Software for Mind Mapping|Creating a Central Idea and Main Branches|Adding Keywords, Images, and Colors|Structuring and Organizing Information Hierarchically|Applications in Brainstorming, Note-Taking, and Planning|Advanced Mind Mapping Techniques and Best Practices" +Brainwriting,"Introduction to Brainwriting as a Collaborative Technique|Comparison with Traditional Brainstorming|Rules and Guidelines for Brainwriting Sessions|Common Brainwriting Methods (e.g., 6-3-5 Method)|Facilitating a Brainwriting Session|Generating Ideas Silently and Iteratively|Reviewing and Categorizing Generated Ideas|Benefits for Introverts and Diverse Teams" +SCAMPER,"Introduction to the SCAMPER Technique|Understanding Each SCAMPER Prompt: Substitute, Combine, Adapt|Understanding Each SCAMPER Prompt: Modify, Put to another use, Eliminate, Reverse|Applying SCAMPER to Products, Services, and Processes|Generating Creative Ideas through Structured Questions|Facilitating a SCAMPER Session|Analyzing and Prioritizing SCAMPER-Generated Ideas|Case Studies and Practical Applications" +Brainstorming Techniques,"Introduction to Idea Generation and Creativity|Principles of Effective Brainstorming|Traditional Brainstorming Rules and Facilitation|Divergent vs. Convergent Thinking|Structured Brainstorming Methods (e.g., Round Robin, Free Association)|Digital Tools for Collaborative Brainstorming|Overcoming Common Brainstorming Challenges (e.g., groupthink)|Evaluating and Prioritizing Brainstormed Ideas" +Discovery,"Introduction to Product Discovery Principles|Understanding User Needs and Pain Points|Market Research and Competitive Analysis|Problem Framing and Hypothesis Generation|User Research Methods (Interviews, Surveys, Observation)|Prototyping and Experimentation for Validation|Defining Minimum Viable Product (MVP)|Iterative Discovery Cycles and Feedback Loops" +Selection,"Introduction to Idea and Feature Prioritization|Defining Selection Criteria (e.g., Impact, Effort, Risk)|Quantitative Prioritization Frameworks (e.g., RICE, ICE)|Qualitative Prioritization Methods (e.g., MoSCoW, Kano Model)|Stakeholder Alignment and Consensus Building|Roadmap Planning and Backlog Management|Decision-Making Under Uncertainty|Communicating Prioritization Decisions" +Statement,"Definition and Types of Statements|Components of a Statement (Subject, Predicate)|Truth Value of Statements (True/False)|Simple vs. Compound Statements (Conjunction, Disjunction)|Conditional and Biconditional Statements|Quantified Statements (Universal, Existential)|Logical Equivalence and Inference" +Proposition,"Definition and Characteristics of a Proposition|Atomic vs. Compound Propositions|Logical Connectives (AND, OR, NOT, IMPLIES)|Truth Tables for Compound Propositions|Tautologies, Contradictions, and Contingencies|Logical Equivalence of Propositions|Argument Validity and Soundness" +Capabilities,Definition and Scope of Capabilities|Identifying Core vs. Supporting Capabilities|Capability Mapping and Modeling|Assessing Current Capability Maturity|Capability Gaps Analysis|Developing New Capabilities|Capability-Based Planning|Measuring Capability Performance +Solved Constraints,Definition and Importance of Constraints|Identifying and Categorizing Constraints|Constraint Analysis Techniques|Strategies for Solving or Mitigating Constraints|Documenting Solved Constraints and Lessons Learned|Impact Assessment of Solved Constraints|Preventing Recurrence of Solved Constraints +Future Constraints,Definition and Types of Future Constraints|Proactive Identification of Potential Constraints|Risk Assessment of Future Constraints|Scenario Planning for Future Constraints|Mitigation Strategies for Anticipated Constraints|Monitoring and Early Warning Systems for Constraints|Incorporating Future Constraints into Planning +Reference Materials,"Types of Reference Materials (Documentation, APIs, Tutorials)|Effective Search Strategies for Reference Materials|Evaluating Credibility and Quality of Sources|Organizing and Managing Reference Materials|Citing and Referencing Best Practices|Creating Internal Reference Documentation|Utilizing Version Control for Documentation" +Narrative,"Definition and Purpose of Narrative|Elements of a Compelling Narrative (Plot, Characters)|Structuring a Narrative (Beginning, Middle, End)|Crafting a Clear and Engaging Story Arc|Using Narrative for Communication and Persuasion|Storytelling Techniques in Business and Technology|Adapting Narratives for Different Audiences" +Defining Goals,"Understanding the Purpose of Goal Setting|Differentiating Goals from Objectives and Tasks|SMART Goal Framework (Specific, Measurable, Achievable, Relevant, Time-bound)|Setting Personal vs. Team vs. Organizational Goals|Aligning Goals with Strategic Vision|Prioritizing Goals and Resource Allocation|Tracking Progress and Adjusting Goals" +Target,Definition and Role of Targets in Planning|Setting Quantitative vs. Qualitative Targets|Aligning Targets with Goals and Objectives|Benchmarking and Competitive Targets|Establishing Realistic and Ambitious Targets|Monitoring Target Achievement and Performance Metrics|Adjusting Targets Based on Performance and Market Changes +Baseline,Definition and Importance of Baselines|Establishing Initial Baselines for Projects and Performance|Data Collection and Measurement for Baselines|Documenting Baseline Scope and Assumptions|Using Baselines for Performance Comparison and Tracking|Re-baselining Procedures and Justification|Baseline Management in Project Control +Trend,"Definition and Types of Trends (Market, Technology, Social)|Identifying and Analyzing Trends|Data Sources for Trend Analysis|Quantitative vs. Qualitative Trend Analysis|Forecasting Future Trends and Impact Assessment|Incorporating Trends into Strategic Planning|Adapting to Emerging Trends" +Timeframe,Definition and Importance of Timeframes in Planning|Setting Realistic Timeframes for Tasks and Projects|Estimating Task Durations and Dependencies|Using Timeframes for Scheduling and Milestones|Managing Time Constraints and Deadlines|Adjusting Timeframes Due to Scope Changes or Risks|Time Management Techniques +Value Proposition,Definition and Core Components of a Value Proposition|Identifying Customer Pains and Gains|Understanding Customer Jobs-to-be-Done|Crafting a Clear and Concise Value Statement|Differentiating Your Value Proposition from Competitors|Testing and Validating Value Propositions|Communicating Value Proposition to Target Audience +Defining Value Proposition,"Introduction to Value Proposition Concepts|Identifying Target Customer Segments|Understanding Customer Needs, Pains, and Gains|Brainstorming Potential Value Elements|Structuring a Value Proposition Statement|Articulating Unique Selling Points|Developing Hypotheses for Value Proposition" +Value Proposition Canvas,"Introduction to the Value Proposition Canvas Framework|Mapping Customer Jobs, Pains, and Gains|Mapping Products/Services, Pain Relievers, and Gain Creators|Achieving Fit between Customer Profile and Value Map|Using the Canvas for Ideation and Design|Identifying Gaps and Opportunities with the Canvas|Iterating and Refining Value Propositions using the Canvas" +Value vs Features,"Differentiating Between Value and Features|Understanding Customer Perception of Value|Translating Features into Customer Benefits|Prioritizing Features Based on Value Impact|Avoiding Feature Overload and Bloat|Communicating Value, Not Just Features|Measuring the Value Delivered by Features" +Finding Balance,"Definition and Importance of Balance in Design and Strategy|Identifying Conflicting Priorities (e.g., speed vs. quality)|Techniques for Prioritization and Trade-off Analysis|Iterative Development and Feedback Loops|Resource Allocation and Optimization|Stakeholder Management and Consensus Building|Adapting Strategies to Maintain Balance" +Feature Creep,"Definition and Causes of Feature Creep|Identifying Early Warning Signs of Feature Creep|Impact of Feature Creep on Projects (Scope, Time, Cost)|Strategies for Preventing Feature Creep (e.g., clear scope)|Managing Stakeholder Expectations|Prioritization Frameworks to Control Features|Communicating Scope Changes and Their Implications" +Competitive Strategy,"Definition and Importance of Competitive Strategy|Porter's Generic Strategies (Cost Leadership, Differentiation)|Analyzing Industry Structure (e.g., Five Forces)|Identifying Competitors and Their Strategies|Developing Sustainable Competitive Advantage|Strategic Positioning and Market Segmentation|Implementing and Monitoring Competitive Strategy" +Five Forces Analysis,Introduction to Porter's Five Forces Framework|Threat of New Entrants Analysis|Bargaining Power of Buyers Analysis|Bargaining Power of Suppliers Analysis|Threat of Substitute Products or Services Analysis|Intensity of Rivalry Among Existing Competitors Analysis|Applying Five Forces to Industry Analysis|Developing Strategic Responses Based on Five Forces +Competetive Advantage,Definition and Types of Competitive Advantage|Porter's Five Forces Analysis|SWOT Analysis for Competitive Positioning|Value Chain Analysis|Sustaining Competitive Advantage|Dynamic Capabilities and Strategic Flexibility|Blue Ocean Strategy +Strategic Partners,"Definition and Types of Strategic Alliances|Benefits and Risks of Partnerships|Identifying Strategic Objectives for Partnerships|Partner Selection Criteria|Legal Frameworks for Partnerships (MOUs, Contracts)|Building Trust and Collaboration|Measuring Partnership Success" +Identify Partners,"Defining Partnership Goals and Scope|Market Research and Landscape Analysis|Criteria for Partner Evaluation|Sourcing Channels (Networking, Industry Events, Databases)|Due Diligence and Risk Assessment|Initial Outreach and Relationship Building|Negotiation Fundamentals" +Managing Partnerships,Establishing Governance Structures|Communication Strategies for Partners|Performance Monitoring and KPIs|Conflict Resolution in Partnerships|Contract Management and Compliance|Value Co-creation and Innovation|Partnership Lifecycle Management (Onboarding to Exit) +Product Requirements,"Definition and Purpose of Product Requirements|Types of Requirements (Functional, Non-functional, Technical)|Stakeholder Identification and Analysis|Requirement Elicitation Techniques (Interviews, Workshops)|Documenting Requirements Clearly and Concisely|Requirement Traceability and Version Control|Validating and Verifying Requirements" +Writing PRDs,Purpose and Structure of a Product Requirements Document (PRD)|Defining Target Audience and Business Goals|Articulating User Stories and Use Cases|Specifying Functional and Non-Functional Requirements|Including Design and Technical Considerations|Review and Approval Process for PRDs|Maintaining and Updating PRDs +User Stories,"Introduction to Agile and User Stories|The 'As a [user], I want [goal], so that [reason]' format|INVEST Criteria for Good User Stories|Acceptance Criteria Definition|Breaking Down Epics into User Stories|Estimating User Story Effort|User Stories in the Development Lifecycle" +Job Stories,"Introduction to Job-to-be-Done (JTBD) Framework|Understanding 'Jobs,' 'Pains,' and 'Gains'|The 'When [situation], I want to [motivation], so I can [expected outcome]' format|Distinguishing Job Stories from User Stories|Applying Job Stories for Product Discovery|Using Job Stories for Feature Prioritization|Measuring Success with Job Stories" +Product Roadmap,"Definition and Purpose of a Product Roadmap|Types of Roadmaps (Theme-based, Outcome-based, Feature-based)|Aligning Roadmap with Business Strategy|Key Components of a Roadmap|Roadmap Horizon and Timeframes|Tools for Roadmap Creation|Common Roadmap Pitfalls" +Creating a Roadmap,"Gathering Strategic Inputs and Vision|Defining Themes and Objectives|Prioritizing Initiatives for the Roadmap|Structuring the Roadmap (Now, Next, Later)|Visualizing and Documenting the Roadmap|Iterative Roadmap Development|Gaining Stakeholder Buy-in" +Prioritising Features,"Understanding the Need for Prioritization|Value vs. Effort Matrix|MoSCoW Prioritization Method|Kano Model for Customer Satisfaction|Weighted Scoring Models (e.g., RICE, WSJF)|Impact Mapping for Strategic Prioritization|Continuous Re-prioritization and Adaptation" +Continuous Roadmapping,Principles of Agile Roadmapping|Regular Review and Update Cycles|Incorporating Feedback Loops|Adapting to Market Changes and New Information|Balancing Short-term and Long-term Goals|Communicating Roadmap Changes Effectively|Tools and Practices for Continuous Roadmapping +Outcome-Based Roadmaps,Introduction to Outcome-Driven Development|Defining Key Outcomes and Metrics (OKRs)|Shifting from Output to Outcome Focus|Structuring Roadmap Around Desired Business Outcomes|Identifying Initiatives to Achieve Outcomes|Measuring Progress Towards Outcomes|Communicating Outcome-Based Roadmaps +Communicating the Roadmap,Identifying Different Stakeholder Audiences|Tailoring Communication for Each Audience|Choosing Appropriate Communication Channels|Presenting the Roadmap Effectively|Handling Questions and Feedback|Managing Expectations Around Roadmap Changes|Ensuring Alignment Across Teams +Backlog Management,"Definition and Purpose of a Product Backlog|Characteristics of a Healthy Backlog (DEEP)|Backlog Item Types (Epics, Features, Stories, Bugs)|Estimating Backlog Items|Ordering and Prioritizing the Backlog|Refining and Grooming the Backlog|Tools for Backlog Management" +Prioritization Techniques,"Value vs. Effort Matrix|MoSCoW Method|Kano Model|RICE Scoring Model (Reach, Impact, Confidence, Effort)|Weighted Shortest Job First (WSJF)|Opportunity Scoring (JTBD)|Buy-a-Feature Game" +Grooming Sessions,Purpose and Benefits of Backlog Grooming|Participants and Roles in Grooming|Agenda and Structure of a Grooming Session|Techniques for Refining Backlog Items|Estimating and Sizing Stories During Grooming|Ensuring Stories are 'Ready' for Development|Facilitating Effective Grooming Sessions +User Story Mapping,Introduction to User Story Mapping|Identifying User Activities and Tasks|Creating the User Journey Backbone|Decomposing Activities into User Stories|Prioritizing Stories for Releases and MVPs|Collaborative Mapping Techniques|Using Story Maps for Release Planning and Communication +UX / UI Design,"Distinction Between UX and UI Design|Core Principles of User-Centered Design|User Research Methods (Interviews, Surveys, Personas)|Information Architecture and Navigation Design|Wireframing and Prototyping Tools|Usability Testing Fundamentals|Visual Design Principles (Typography, Color, Layout)|Accessibility in Design" +Principles of UX Design,User-Centered Design Philosophy|Usability Heuristics (Nielsen's 10 Heuristics)|Accessibility Guidelines (WCAG)|Consistency and Standards|Feedback and Feedforward|Error Prevention and Recovery|Cognitive Load and Simplicity|Emotional Design and Delight +Wireframing and Prototyping,"Introduction to UX Design Principles|Understanding User Flows and Information Architecture|Low-Fidelity Wireframing (Sketches, Digital Tools)|Mid-Fidelity Wireframing and Annotations|Prototyping Tools and Techniques (e.g., Figma, Adobe XD)|Interactive Prototyping and Microinteractions|Usability Heuristics and Design Patterns|Testing Prototypes with Users" +Design Thinking,Introduction to Human-Centered Design|Empathize: User Research and Persona Creation|Define: Problem Statement and Point-of-View|Ideate: Brainstorming Techniques and Solutions|Prototype: Building Tangible Representations|Test: Gathering Feedback and Iteration|Applying Design Thinking in Business Contexts +Interaction Design,Fundamentals of Human-Computer Interaction (HCI)|Usability Principles and Heuristics|Information Architecture and Navigation Design|Feedback and Affordances|Designing for Different Devices and Contexts (Responsive Design)|Microinteractions and Animations|Accessibility in Interaction Design|Cognitive Psychology in UX +User Testing,Introduction to User Research Methodologies|Defining Research Goals and Hypotheses|Recruiting Participants for User Testing|Developing Test Scenarios and Tasks|Moderated vs. Unmoderated User Testing|Observing and Documenting User Behavior|Analyzing User Testing Data and Reporting Findings|Ethical Considerations in User Testing +Usability Testing,"Distinction between User Testing and Usability Testing|Key Usability Metrics (Time on Task, Success Rate, Errors)|Planning and Scripting Usability Tests|Conducting Moderated Usability Sessions|Analyzing Qualitative and Quantitative Usability Data|Identifying Usability Issues and Prioritization|Reporting Usability Findings and Recommendations|Iterative Usability Testing" +Remote User Testing,"Advantages and Challenges of Remote Testing|Tools for Remote Moderated Testing (e.g., Zoom, Google Meet)|Tools for Remote Unmoderated Testing (e.g., UserTesting, Lookback)|Designing Effective Remote Test Scenarios|Recruiting and Managing Remote Participants|Analyzing Remote Session Recordings and Data|Best Practices for Remote Facilitation" +Agile Methodology,"Introduction to Agile Principles and Values (Manifesto)|Scrum Framework Overview|Kanban Method Overview|Roles in Agile Teams (Product Owner, Scrum Master, Dev Team)|Agile Ceremonies (Sprint Planning, Daily Scrum, Review, Retrospective)|User Stories and Backlog Management|Estimation Techniques (Story Points, Planning Poker)|Continuous Integration and Continuous Delivery (CI/CD)" +Working with Engineering Teams,"Understanding the Software Development Lifecycle (SDLC)|Effective Communication Strategies with Engineers|Translating Design Specifications into Technical Requirements|Managing Technical Debt and Trade-offs|Participating in Code Reviews (from a non-coding perspective)|Bug Reporting and Tracking Best Practices|Collaborative Tools and Workflows (Jira, GitHub, Confluence)|Building Empathy and Trust with Engineering" +Sprint Planning,Purpose and Goals of Sprint Planning|Reviewing the Product Backlog and Prioritization|Understanding Team Capacity and Velocity|Selecting Backlog Items for the Sprint|Breaking Down User Stories into Tasks|Defining the Sprint Goal|Commitment and Forecast in Sprint Planning|Dealing with Dependencies and Risks +Daily Standups,"Purpose and Format of the Daily Scrum|The 'Three Questions' (What did I do, What will I do, Impediments)|Keeping Standups Concise and Focused|Identifying and Addressing Impediments|Team Synchronization and Progress Tracking|Facilitating Effective Daily Standups|Common Pitfalls and How to Avoid Them" +Retrospectives,"Purpose and Value of Sprint Retrospectives|Setting the Stage and Gathering Data|Generating Insights (What went well, What could be improved)|Deciding What to Do (Actionable Improvements)|Closing the Retrospective and Follow-up|Different Retrospective Formats and Activities|Creating a Culture of Continuous Improvement|Facilitating Difficult Conversations" +Minimum Viable Product (MVP),Defining the Core Value Proposition|Identifying the Smallest Set of Features|Prioritization Techniques for MVP|Lean Startup Principles and Build-Measure-Learn Loop|Testing Assumptions with an MVP|Iterating and Evolving from an MVP|Avoiding Scope Creep in MVP Development +Go-to-Market Strategy,"Understanding Market Research and Target Audience|Defining Product Positioning and Messaging|Pricing Strategies and Models|Distribution Channels and Sales Strategy|Marketing Mix (Product, Price, Place, Promotion)|Competitive Analysis and Differentiation|Developing a GTM Plan Document|Measuring GTM Success Metrics" +Launch Planning,"Setting Launch Goals and Objectives|Defining Target Audience and Key Markets|Developing a Detailed Launch Timeline|Cross-Functional Team Coordination (Marketing, Sales, PR, Support)|Pre-Launch Activities (Beta Programs, Press Kits)|Launch Day Execution and Monitoring|Post-Launch Analysis and Follow-up|Contingency Planning for Launch Risks" +Marketing Strategies,"Introduction to Marketing Fundamentals|Digital Marketing Channels (SEO, SEM, Social Media, Email)|Content Marketing and Storytelling|Inbound vs. Outbound Marketing|Brand Building and Messaging|Performance Marketing and Analytics|Customer Relationship Management (CRM)|Developing a Comprehensive Marketing Plan" +Growth Hacking,"Introduction to Growth Mindset and Experimentation|AARRR Funnel (Acquisition, Activation, Retention, Referral, Revenue)|Data-Driven Experimentation and A/B Testing|Leveraging Product for Growth (Virality, Referrals)|Optimizing Onboarding and Activation|Retention Strategies and Engagement Loops|Growth Hacking Tools and Analytics|Ethical Considerations in Growth Hacking" +Release Strategies,"Understanding Different Release Cadences (Continuous, Scheduled)|Feature Flags and Toggles|Canary Releases and Blue/Green Deployments|Phased Rollouts and A/B Testing Releases|Dark Launches and Shadowing|Rollback Procedures and Disaster Recovery|Communication and Coordination for Releases|Monitoring and Post-Release Analysis" +Feature Toggles,"Introduction to Feature Flag Concepts|Use Cases for Feature Toggles (A/B Testing, Canary Releases, Kill Switches)|Implementing Feature Toggles in Code|Managing Feature Flags (Tools and Platforms)|Best Practices for Naming and Organizing Toggles|Testing Strategies for Feature-Flagged Code|Lifecycle Management of Feature Toggles (Cleanup)|Security and Performance Considerations" +Phased Rollouts,Purpose and Benefits of Phased Rollouts|Defining User Segments for Rollout Phases|Gradual Exposure and Risk Mitigation|Monitoring Key Metrics During Rollout|Gathering Feedback and Iterating Between Phases|Tools and Techniques for Managing Phased Rollouts|Communication Strategies for Phased Releases|Scaling Up or Rolling Back Decisions +Dark Launches,Definition and Purpose of Dark Launches (Shadowing)|Technical Implementation of Dark Launches|Monitoring Performance and Stability in Production|Validating Scalability and Reliability Under Load|Comparing Dark Launch Results with Existing Systems|Risk Assessment and Mitigation for Dark Launches|When to Use Dark Launches vs. Other Strategies|Analyzing Data from Dark Launches to Inform Decisions +Key Product Metrics,"Introduction to Product Metrics|Types of Product Metrics (Quantitative vs. Qualitative)|Leading vs. Lagging Indicators|Frameworks for Metric Selection (e.g., AARRR, HEART)|Defining and Tracking Key Performance Indicators (KPIs)|Data Visualization and Reporting for Metrics|A/B Testing and Metric Impact Analysis|Metric-Driven Decision Making" +DAU (Daily Active Users),"Definition and Importance of DAU|Methods for Calculating DAU (Login, Event-based)|Factors Influencing DAU|Benchmarking DAU Against Competitors|Strategies to Increase DAU|DAU vs. WAU vs. MAU Comparison|Pitfalls and Misinterpretations of DAU" +MAU (Monthly Active Users),"Definition and Significance of MAU|Calculation Methodologies for MAU|Understanding MAU Trends and Seasonality|MAU as a Growth and Engagement Indicator|Strategies for Sustaining and Growing MAU|Relationship between DAU, WAU, and MAU|MAU in Different Business Models" +Conversion Rate,"Definition and Importance of Conversion Rate|Types of Conversions (e.g., Sign-up, Purchase, Trial)|Calculating Conversion Rate|Identifying Conversion Funnels and Drop-off Points|A/B Testing for Conversion Rate Optimization (CRO)|User Experience (UX) Impact on Conversion|Personalization and Segmentation for CRO|Tools and Techniques for CRO" +Retention Rate,"Definition and Significance of Retention Rate|Calculating Retention Rate (N-day, Unbounded)|Types of Retention (User, Revenue, Feature)|Factors Affecting User Retention|Strategies for Improving Retention (Onboarding, Engagement)|Cohort Analysis for Retention Insights|Measuring Long-Term Retention and LTV Impact" +Churn Rate,"Definition and Importance of Churn Rate|Calculating Customer Churn Rate|Types of Churn (Voluntary, Involuntary, Revenue Churn)|Identifying Causes of Churn|Predictive Churn Modeling|Strategies for Churn Prevention and Reduction|Impact of Churn on Business Growth" +LTV (Lifetime Value),"Definition and Significance of LTV|Basic LTV Calculation Methods|Factors Influencing Customer Lifetime Value|Advanced LTV Models (e.g., Predictive LTV)|Using LTV for Customer Segmentation|Strategies to Increase LTV|Relationship between LTV and CAC" +CAC (Customer Acquisition Cost),Definition and Importance of CAC|Components of Customer Acquisition Cost|Calculating CAC (Simple vs. Blended)|Benchmarking CAC Across Industries|Strategies for Optimizing CAC|Relationship between CAC and LTV|Unit Economics and CAC Analysis +North Star Metric,Understanding the Concept of a North Star Metric|Characteristics of an Effective North Star Metric|Process for Identifying a North Star Metric|Aligning Teams Around the North Star Metric|Cascading Metrics from the North Star|Common Pitfalls in North Star Metric Selection|Examples of North Star Metrics in Practice +Cohort Analysis,"Introduction to Cohort Analysis|Defining Cohorts (Time-based, Behavioral)|Setting Up Cohort Data for Analysis|Interpreting Cohort Tables and Graphs|Applying Cohort Analysis to Retention|Using Cohort Analysis for Feature Adoption|Advanced Cohort Segmentation Techniques" +Predictive Analytics,"Introduction to Predictive Analytics Concepts|Data Collection and Preparation for Prediction|Common Predictive Modeling Techniques (Regression, Classification)|Machine Learning Algorithms for Prediction|Evaluating Predictive Model Performance|Applications of Predictive Analytics (e.g., Churn Prediction, LTV Prediction)|Ethical Considerations in Predictive Analytics" +Feedback Loops,"Understanding the Concept of Feedback Loops|Types of Feedback Loops (Positive, Negative, Balancing)|Designing Effective Feedback Mechanisms|Collecting User Feedback (Surveys, Interviews, Analytics)|Analyzing and Synthesizing Feedback Data|Implementing Feedback into Product Development|Closing the Loop with Users and Stakeholders" +Interpersonal,Understanding Interpersonal Dynamics|Building Rapport and Trust|Non-Verbal Communication Skills|Empathy and Perspective-Taking|Giving and Receiving Feedback Effectively|Navigating Difficult Social Situations|Building and Maintaining Professional Relationships +Business,Fundamentals of Business Operations|Understanding Business Models and Value Proposition|Market Analysis and Competitive Landscape|Financial Literacy for Business Professionals|Strategic Planning and Goal Setting|Project Management in a Business Context|Business Ethics and Corporate Social Responsibility +Communication Techniques,"Fundamentals of Effective Communication|Verbal Communication Skills (Clarity, Conciseness)|Written Communication Best Practices|Active Listening and Empathetic Responses|Adapting Communication Styles to Audiences|Presenting Information Effectively|Giving and Receiving Constructive Feedback" +Difficult Conversations,Understanding the Nature of Difficult Conversations|Preparing for a Difficult Conversation|Setting the Right Environment and Tone|Active Listening and Empathy in Conflict|Expressing Your Perspective Clearly and Respectfully|Managing Emotions During Conflict|Finding Common Ground and Resolution Strategies +Active Listening,"Definition and Importance of Active Listening|Core Principles of Active Listening|Verbal Cues for Active Listening (Paraphrasing, Summarizing)|Non-Verbal Cues for Active Listening (Eye Contact, Body Language)|Overcoming Barriers to Active Listening|Practicing Empathetic Listening|Applying Active Listening in Professional Settings" +Conflict Resolution,"Understanding the Nature and Causes of Conflict|Identifying Conflict Styles (e.g., Avoiding, Collaborating)|Strategies for De-escalating Conflict|Mediation and Facilitation Techniques|Collaborative Problem-Solving Approaches|Negotiating Win-Win Solutions|Post-Conflict Follow-up and Relationship Repair" +Alignment & Buy-In,Understanding the Importance of Alignment|Identifying Stakeholders and Their Interests|Crafting a Compelling Vision and Strategy|Communicating Value and Benefits Effectively|Building Consensus Through Collaboration|Addressing Objections and Concerns|Sustaining Alignment and Commitment +Showing Impact,Defining and Measuring Impact|Identifying Key Performance Indicators (KPIs) for Impact|Collecting and Analyzing Relevant Data|Quantifying Results and Outcomes|Storytelling with Data and Metrics|Communicating Impact to Different Audiences|Linking Work to Organizational Goals and Strategy +Managing Stakeholders,Introduction to Stakeholder Management Principles|Developing a Stakeholder Management Plan|Effective Communication Strategies for Stakeholders|Conflict Resolution and Negotiation with Stakeholders|Adapting Strategies for Diverse Stakeholder Groups|Measuring and Reporting Stakeholder Satisfaction +Identifying Stakeholders,Definition and Types of Project Stakeholders|Brainstorming and Initial Stakeholder Discovery|Analyzing Project Documentation for Stakeholders|Interviewing and Workshops for Stakeholder Identification|Validating and Documenting Stakeholder Lists +Stakeholder Mapping,"Introduction to Stakeholder Mapping Models (e.g., Power/Interest Grid)|Data Collection for Mapping Inputs|Plotting Stakeholders on Mapping Grids|Interpreting Mapping Results and Implications|Dynamic Nature of Stakeholder Maps and Updates" +Stakeholder Engagement,Principles of Effective Stakeholder Engagement|Developing a Comprehensive Engagement Strategy|Communication Planning for Engagement Activities|Facilitating Workshops and Meetings with Stakeholders|Building Trust and Relationships with Stakeholders|Measuring Engagement Effectiveness and Feedback +Remote Stakeholders,Challenges of Engaging Remote Stakeholders|Best Practices for Virtual Communication and Collaboration|Tools and Technologies for Remote Stakeholder Interaction|Building Trust and Rapport Remotely|Managing Time Zones and Cultural Differences|Ensuring Inclusivity for Remote Participants +Roadmapping Tools,Introduction to Product Roadmapping Concepts|Overview of Different Roadmapping Tool Categories|Key Features and Functionalities of Roadmapping Tools|Creating and Managing Roadmaps within Tools|Integrating Roadmapping Tools with Other Systems|Best Practices for Tool Selection and Implementation +Analytics Tools,"Introduction to Data Analytics and Business Intelligence|Types of Analytics Tools (e.g., Web, Product, BI)|Core Features: Data Collection, Visualization, Reporting|Setting Up Tracking and Event Definitions|Performing Basic Data Analysis and Interpretation|Advanced Features: Segmentation, Funnels, A/B Testing|Integrating Analytics Tools with Data Sources" +Communication Tools,"Overview of Communication Tool Categories (e.g., Chat, Video, Email)|Core Features and Use Cases for Each Tool Type|Best Practices for Effective Digital Communication|Integrating Communication Tools into Workflows|Security and Privacy Considerations for Communication Tools|Selecting the Right Tools for Team Needs" +Product Board,Introduction to Productboard and its Core Philosophy|Capturing and Organizing Customer Feedback (Insights)|Prioritizing Features with Productboard's Scoring Models|Building and Sharing Roadmaps within Productboard|Collaborating with Teams on Product Strategy|Integrating Productboard with Development Tools +Aha,Introduction to Aha! and its Product Management Framework|Defining Strategy and Initiatives in Aha!|Capturing Ideas and Requirements|Building Roadmaps and Releases in Aha!|Managing Development and Tracking Progress|Reporting and Analytics within Aha! +Notion,"Introduction to Notion's Flexible Workspace Concept|Creating Pages, Databases, and Workspaces|Organizing Information with Blocks and Templates|Collaborating and Sharing Content in Notion|Using Notion for Project Management and Task Tracking|Advanced Database Features and Relations|Integrating Notion with Other Applications" +Trello,"Introduction to Kanban Principles and Trello Basics|Creating Boards, Lists, and Cards|Managing Tasks with Due Dates, Checklists, and Labels|Collaborating with Team Members on Trello Boards|Using Power-Ups and Integrations for Enhanced Functionality|Advanced Workflow Automation with Trello" +Amplitude,"Introduction to Product Analytics and Amplitude's Role|Understanding Amplitude's Data Model (Events, Users, Properties)|Setting Up Tracking and Instrumenting Events|Building Basic Charts: Event Segmentation, Funnels, Retention|Creating Dashboards and Reports for Insights|Advanced Analysis: User Journeys, Behavioral Cohorts|Integrating Amplitude with Data Sources and Destinations" +Heap,"Introduction to Codeless Analytics and Heap's Auto-Capture|Understanding Heap's Data Model and Event Definitions|Defining Events and Properties Retroactively|Building Reports: Funnels, Journeys, Retention|Creating Dashboards and Sharing Insights|Segmenting Users and Analyzing User Behavior|Integrating Heap with Other Tools" +Slack,"Introduction to Slack and Channel-Based Communication|Creating and Managing Channels (Public, Private, Shared)|Sending Messages, Files, and Using Threads|Utilizing Mentions, Reactions, and Emojis|Integrating Apps and Services with Slack|Advanced Features: Workflows, Huddles, Canvas|Best Practices for Team Communication in Slack" +Teams,"Introduction to Microsoft Teams and its Ecosystem|Creating and Managing Teams and Channels|Chat, Video Calls, and Meetings in Teams|Sharing Files and Collaborating on Documents|Integrating Microsoft 365 Apps and Third-Party Services|Using Teams for Project Management and Task Tracking|Advanced Features: Webinars, Breakout Rooms, Approvals" +Discord,"Introduction to Discord for Community and Communication|Creating and Managing Servers, Channels, and Roles|Text, Voice, and Video Chat Functionality|Using Bots and Integrations for Server Enhancement|Moderating Communities and Managing Permissions|Streaming and Screen Sharing Features|Building and Engaging a Community on Discord" +Identifying Risks,"Definition of Risk and Risk Management Fundamentals|Types of Risks (e.g., Technical, Business, Operational)|Brainstorming Techniques for Risk Discovery|Reviewing Documentation for Potential Risks|Interviewing Stakeholders for Risk Insights|Categorizing and Initial Documentation of Identified Risks" +Risk Identification Techniques,Introduction to Structured Risk Identification Methods|Brainstorming and Delphi Technique for Risk Discovery|SWOT Analysis for Risk Identification|Checklists and Prompt Lists for Comprehensive Coverage|Interviewing and Workshops for Stakeholder Input|Root Cause Analysis and Fault Tree Analysis|Document Review and Assumption Analysis +Risk Register,"Purpose and Components of a Risk Register|Documenting Identified Risks (Description, Category)|Assigning Risk Owners and Initial Impact/Likelihood|Tracking Risk Status and Mitigation Actions|Updating and Maintaining the Risk Register|Reporting from the Risk Register|Integrating Risk Register with Project Management Tools" +Risk Assessment,"Definition and Purpose of Risk Assessment|Identifying Assets and Vulnerabilities|Threat Identification and Categorization|Likelihood and Impact Analysis|Risk Matrix and Prioritization|Risk Treatment Options Overview|Risk Assessment Frameworks (e.g., NIST, ISO 27005)|Reporting and Communicating Risks" +Qualitative Risk Assessment,"Introduction to Qualitative vs. Quantitative Risk|Methods for Qualitative Risk Identification (Brainstorming, Interviews)|Defining Likelihood Scales (e.g., Low, Medium, High)|Defining Impact Scales (e.g., Minor, Moderate, Major)|Constructing a Qualitative Risk Matrix|Interpreting and Prioritizing Qualitative Risks|Limitations and Benefits of Qualitative Assessment" +Quantitative Risk Assessment,"Introduction to Quantitative Risk Metrics|Data Collection for Quantitative Analysis (Historical Data, Surveys)|Single Loss Expectancy (SLE) Calculation|Annualized Loss Expectancy (ALE) Calculation|Monte Carlo Simulation for Risk Analysis|Cost-Benefit Analysis of Risk Controls|Interpreting and Reporting Quantitative Risk Results|Tools and Software for Quantitative Risk Assessment" +Risk Mitigation,"Definition and Goals of Risk Mitigation|Risk Treatment Strategies (Avoid, Transfer, Mitigate, Accept)|Developing Risk Mitigation Plans|Implementing Controls (Technical, Administrative, Physical)|Cost-Benefit Analysis of Mitigation Controls|Residual Risk Understanding|Documenting Mitigation Actions" +Mitigation Strategies,"Preventative Controls Implementation|Detective Controls Implementation|Corrective Controls Implementation|Risk Avoidance Techniques|Risk Transfer Mechanisms (Insurance, Outsourcing)|Risk Acceptance Criteria and Justification|Developing a Comprehensive Mitigation Strategy" +Contingency Planning,"Definition and Importance of Contingency Planning|Business Impact Analysis (BIA) Fundamentals|Identifying Critical Business Functions and Resources|Developing Recovery Time Objectives (RTO) and Recovery Point Objectives (RPO)|Creating Contingency Plans (e.g., Disaster Recovery, Business Continuity)|Testing and Exercising Contingency Plans|Maintaining and Updating Contingency Plans" +Monitoring and Controlling Risks,Establishing Risk Monitoring Metrics and KPIs|Regular Risk Reviews and Reporting|Tracking Risk Status and Trends|Identifying New and Emerging Risks|Evaluating Effectiveness of Risk Controls|Risk Register Management|Continuous Improvement in Risk Management +Risk Monitoring Tools,"Introduction to Risk Management Information Systems (RMIS)|Spreadsheet-based Risk Registers|GRC (Governance, Risk, and Compliance) Platforms|Threat Intelligence Platforms Integration|Vulnerability Scanners and Penetration Testing Tools|Security Information and Event Management (SIEM) Systems|Dashboards and Reporting for Risk Visualization" +Risk Audits,"Purpose and Scope of Risk Audits|Audit Planning and Methodology|Gathering Audit Evidence (Documentation Review, Interviews)|Assessing Compliance with Risk Policies and Procedures|Evaluating Effectiveness of Risk Controls|Identifying Gaps and Non-Compliance|Reporting Audit Findings and Recommendations|Follow-up and Verification of Corrective Actions" +Scaling Products,"Understanding Product-Market Fit and Growth Stages|Identifying Scalability Challenges (Technical, Organizational, Market)|Architectural Considerations for Scalability (Microservices, Distributed Systems)|Performance Optimization Techniques|Data Management for Scale (Databases, Caching)|Operational Scalability (DevOps, Automation)|Organizational Scaling and Team Structures|Internationalization and Localization for Global Scale" +Growth Strategies,"Defining Growth Metrics and KPIs (e.g., ARR, MAU, Churn)|User Acquisition Channels and Tactics|User Activation and Onboarding Optimization|Retention Strategies and Engagement Loops|Monetization Models and Pricing Strategies|Referral Programs and Viral Loops|Product-Led Growth Principles|Experimentation and A/B Testing for Growth" +Internationalization,Understanding Cultural Nuances and Market Differences|Localization vs. Internationalization Concepts|Designing for Multiple Languages (UI/UX Considerations)|Handling Different Currencies and Payment Methods|Legal and Regulatory Compliance Across Regions|Data Privacy and GDPR/CCPA Considerations|Global Infrastructure and Content Delivery Networks (CDNs)|International SEO and Marketing Strategies +Platform Thinking,Defining Platforms vs. Products|Understanding Network Effects and Their Importance|Identifying Core Value Exchange in a Platform|Designing for Two-Sided Markets (Producers and Consumers)|Ecosystem Development and API Strategy|Governance and Trust in Platform Environments|Monetization Strategies for Platforms|Measuring Platform Health and Growth +Portfolio Management,"Introduction to Product Portfolio Management|Strategic Alignment and Business Objectives|Portfolio Prioritization Frameworks (e.g., WSJF, RICE)|Resource Allocation Across Products|Risk Management within a Portfolio|Performance Tracking and Reporting for Portfolios|Balancing Innovation, Growth, and Maintenance Products|Portfolio Roadmapping and Strategic Planning" +Advanced Analysis,Statistical Significance and Hypothesis Testing|Regression Analysis for Predictive Modeling|Cohort Analysis for User Behavior|Funnel Analysis and Conversion Optimization|A/B Testing and Multivariate Testing Design|Causal Inference and Experimentation Design|Data Visualization for Complex Insights|Machine Learning Fundamentals for Data Analysis +ML in Product Mgmt.,"Understanding Machine Learning Fundamentals for PMs|Identifying Use Cases for ML in Products|Data Requirements and Collection for ML Models|Model Training, Evaluation, and Deployment Lifecycle|Ethical Considerations and Bias in ML Models|A/B Testing ML-Powered Features|Measuring Impact and ROI of ML Features|Communicating ML Concepts to Stakeholders" +AI in Product Mgmt.,"Differentiating AI, ML, and Deep Learning for PMs|Identifying AI Opportunities Across Product Lifecycle|Understanding AI Capabilities (NLP, Computer Vision, Generative AI)|Data Strategy for AI Products|User Experience Design for AI-Powered Features|Ethical AI Principles and Responsible AI Development|Measuring AI Product Performance and User Adoption|AI Governance and Risk Management" +Leadership and Influence,Defining Leadership Styles and Their Impact|Effective Communication Strategies|Building Trust and Credibility|Delegation and Empowerment Techniques|Conflict Resolution and Negotiation Skills|Motivating and Inspiring Teams|Strategic Thinking and Vision Setting|Emotional Intelligence in Leadership +Building and Leading Teams,"Team Formation and Dynamics (Tuckman's Stages)|Defining Roles, Responsibilities, and Expectations|Fostering Psychological Safety and Trust|Effective Feedback and Coaching Techniques|Managing Team Performance and Accountability|Conflict Resolution within Teams|Promoting Diversity, Equity, and Inclusion|Remote and Hybrid Team Management" +Influencing without Authority,"Understanding Sources of Influence (Expertise, Relationships)|Building Strong Professional Relationships|Active Listening and Empathy Skills|Persuasion Techniques and Framing Arguments|Negotiating and Finding Common Ground|Storytelling for Impact and Buy-in|Building Coalitions and Alliances|Demonstrating Value and Credibility" +Learn the basics,"What is the Internet and Web Browsers|Client-Server Architecture Fundamentals|HTML Document Structure and Elements|CSS Styling Fundamentals and Selectors|JavaScript Core Concepts (Variables, Data Types, Functions)|Using Browser Developer Tools|Basic Command Line Interface (CLI) Usage|Introduction to Version Control Systems (Git)|Understanding Web Hosting and Domains" +Writing Semantic HTML,"HTML Document Structure (DOCTYPE, head, body)|Block vs. Inline Elements|Semantic Sectioning Elements (header, nav, main, article, section, aside, footer)|Text Semantics (headings, paragraphs, strong, em, blockquote)|Lists (unordered, ordered, description lists)|Tables for Tabular Data (table, tr, th, td)|Media Elements (img, audio, video) and Accessibility|HTML5 New Features (data attributes, custom elements intro)|Accessibility Best Practices (ARIA attributes)" +Forms and Validations,"Basic Form Structure (form tag, action, method)|Common Input Types (text, password, email, number, date, checkbox, radio)|Form Controls (textarea, select, button, label)|HTML5 Form Validation Attributes (required, minlength, pattern)|Client-Side JavaScript Validation Basics|Custom Validation Messages and User Feedback|Form Submission and Data Handling (GET vs POST)|Accessibility in Forms (fieldset, legend, for attribute)|Introduction to Server-Side Validation Concepts" +SEO Basics,"Introduction to Search Engine Optimization (SEO)|Keyword Research and Placement Strategies|On-Page SEO (Title Tags, Meta Descriptions, Header Tags)|Content Optimization for Search Engines|Image Optimization (Alt Text, File Size)|Technical SEO (Sitemaps, Robots.txt, Canonical Tags)|Mobile-Friendliness and Page Speed Optimization|Google Search Console and Analytics Introduction|Understanding Backlinks and Off-Page SEO" +Making Layouts,"The CSS Box Model (Content, Padding, Border, Margin)|Display Properties (block, inline, inline-block, none)|Positioning Contexts (static, relative, absolute, fixed, sticky)|Float Layouts and Clearfix Techniques|Flexbox Fundamentals (Container and Item Properties)|Advanced Flexbox Techniques (Alignment, Ordering, Responsiveness)|CSS Grid Layout Basics (Grid Container, Grid Items)|Complex Grid Layouts (Grid Areas, Implicit Grids)|Layout Best Practices and Performance Considerations" +Responsive Design,"Understanding Viewports and Device Pixels|Fluid Grids and Flexible Images|Media Queries Syntax and Breakpoints|Mobile-First vs. Desktop-First Approaches|Responsive Typography and Sizing Units (rem, em, vw, vh)|Implementing Responsive Navigation Patterns|Performance Considerations for Responsive Sites|Testing Responsive Designs with Browser Dev Tools|Accessibility in Responsive Web Design" +Fetch API / Ajax (XHR),"Introduction to Asynchronous JavaScript|XMLHttpRequest (XHR) Basics|Understanding JavaScript Promises (Pending, Fulfilled, Rejected)|Fetch API Fundamentals (Making GET Requests)|Handling Fetch Responses (json(), text(), blob())|Making POST, PUT, and DELETE Requests with Fetch|Error Handling with Fetch (try/catch, .catch())|Async/Await Syntax for Cleaner Asynchronous Code|CORS (Cross-Origin Resource Sharing) Concepts" +Learn DOM Manipulation,"What is the Document Object Model (DOM)|Selecting Elements (getElementById, querySelector, querySelectorAll)|Modifying Element Content (textContent, innerHTML)|Changing Element Attributes (setAttribute, getAttribute, removeAttribute)|Styling Elements Dynamically (style property, classList)|Creating and Appending New Elements (createElement, appendChild)|Removing Elements from the DOM (removeChild, remove)|Event Handling (addEventListener, event object)|Event Delegation and Propagation" +VCS Hosting,"Introduction to Version Control Systems (Git)|Benefits of VCS Hosting (Collaboration, Backup)|GitHub Basics (Repositories, Commits, Branches)|Cloning and Forking Repositories|Pushing and Pulling Changes to Remote Repositories|Pull Requests / Merge Requests Workflow|Resolving Merge Conflicts|GitHub Issues and Project Management Features|Introduction to GitLab and Bitbucket" +Package Managers,"What are Package Managers and Their Purpose|Node.js and npm Installation|Initializing a Project with npm (npm init)|Installing and Managing Dependencies (npm install, npm uninstall)|Understanding package.json and package-lock.json|Running Scripts with npm (npm run)|Global vs. Local Packages|Dependency Types (dependencies, devDependencies)|Security Audits and Updates (npm audit, npm update)" +yarn,"Yarn Installation and Setup|Yarn vs. npm: Key Differences and Advantages|Initializing Projects with Yarn (yarn init)|Adding and Removing Dependencies (yarn add, yarn remove)|Understanding yarn.lock File|Running Scripts with Yarn (yarn run)|Yarn Workspaces for Monorepos|Yarn Plug'n'Play (PnP) Concept|Migrating Projects from npm to Yarn" +pnpm,"pnpm Installation and Setup|pnpm's Unique Approach (Content-Addressable Store, Symlinks)|Advantages of pnpm (Disk Space Efficiency, Speed)|Initializing Projects with pnpm (pnpm init)|Adding and Removing Dependencies (pnpm add, pnpm remove)|Understanding pnpm-lock.yaml File|Running Scripts with pnpm (pnpm run)|pnpm Workspaces for Monorepos|Migrating Projects from npm/Yarn to pnpm" +Pick a Framework,"Why Use a JavaScript Framework|Understanding the Framework Ecosystem (SPA, SSR, SSG)|Key Differences Between Frameworks (Virtual DOM, Reactivity)|Component-Based Architecture Principles|Common State Management Patterns|Client-Side Routing Concepts|Build Tools and Development Servers|Performance Considerations in Frameworks|Criteria for Choosing the Right Framework" +Vue.js,"Vue Instance and Data Binding (v-bind, v-model)|Component Basics (Props, Events, Slots)|Conditional Rendering (v-if, v-show) and List Rendering (v-for)|Computed Properties and Watchers|Lifecycle Hooks (created, mounted, updated)|Vue Router for Navigation|State Management with Pinia (or Vuex)|Composition API (setup, ref, reactive)|Server-Side Rendering with Nuxt.js" +Svelte,"Svelte Component Structure (.svelte files)|Reactivity and State Management ($: syntax)|Props and Event Handling in Svelte|Conditional and List Rendering|Lifecycle Functions (onMount, onDestroy)|Svelte Stores for Global State Management|Transitions and Animations|SvelteKit for Full-Stack Applications|Context API and Component Composition" +Solid JS,"Solid's Reactive Primitives (createSignal, createEffect, createMemo)|JSX Syntax and Component Structure|Props and Event Handling|Control Flow Components (Show, For)|Lifecycle Hooks (onMount, onCleanup)|Context API for State Sharing|Stores and Global State Management|Server-Side Rendering and Hydration|Performance Optimization Techniques" +Qwik,Resumability and Qwik's Core Principles|Qwik Components and JSX|Signals and State Management|Event Handling and Listeners|Lazy Loading and Code Splitting|Qwik City for Routing and Data Fetching|Server-Side Rendering and Hydration|Optimizing for Core Web Vitals|Deployment and Production Best Practices +Writing CSS,"CSS Syntax and Basic Selectors (Type, Class, ID)|Specificity, Cascade, and Inheritance|Units (px, em, rem, %, vw, vh) and Color Formats (hex, rgb, hsl)|Text and Font Styling Properties|Box Model and Sizing Properties|Backgrounds and Borders|Basic Layouts (Display, Position, Floats)|Transitions and Transforms|Media Queries for Responsiveness" +Tailwind,"Utility-First CSS Philosophy|Installation and Setup (PostCSS, PurgeCSS)|Core Utility Classes (Spacing, Typography, Colors, Flexbox)|Responsive Design with Tailwind Breakpoints|Customizing Tailwind Configuration (tailwind.config.js)|Applying Styles Conditionally (Hover, Focus, Dark Mode)|Extracting Components with @apply|Tailwind Plugins and Extending Functionality|Performance Optimization (JIT, PurgeCSS)" +CSS Architecture,"Challenges of Large-Scale CSS|Modular CSS Principles|BEM (Block, Element, Modifier) Methodology|SMACSS (Scalable and Modular Architecture for CSS)|ITCSS (Inverted Triangle CSS)|CSS-in-JS Concepts (Styled Components, Emotion)|Atomic CSS Principles|CSS Variables and Design Systems|Linting and Best Practices for Maintainable CSS" +CSS Preprocessors,"Introduction to CSS Preprocessors and Benefits|Variables and Nesting in Preprocessors|Mixins and Functions for Reusability|Partials and Imports for Modular CSS|Control Directives (Conditionals, Loops)|Integrating Preprocessors with Build Tools" +BEM,Introduction to BEM Methodology|Understanding Blocks in BEM|Defining Elements within Blocks|Applying Modifiers for Variations|BEM Naming Conventions and Best Practices|Implementing BEM with CSS Preprocessors +Sass,"Sass vs. SCSS Syntax Overview|Variables and Data Types in Sass|Nesting Rules and Parent Selector|Mixins and Functions for Code Reusability|Partials and `@import` for Modular Stylesheets|Control Directives (`@if`, `@for`, `@each`, `@while`)|Extending and Inheritance with `@extend`|Sass Modules and Namespacing|Integrating Sass into Build Workflows" +PostCSS,"What is PostCSS and its Core Concepts|Understanding the PostCSS Plugin Ecosystem|Using Autoprefixer with PostCSS|Implementing CSS Variables and Custom Properties|PostCSS for Future CSS Features (e.g., Nesting)|Integrating PostCSS into Build Pipelines" +Build Tools,"Introduction to Build Tools and their Purpose|Common Build Tool Tasks (Compilation, Minification)|Task Runners vs. Module Bundlers|Configuring Basic Build Scripts|Optimizing Assets (Images, Fonts)|Automating Development Workflows (Watch, Live Reload)|Integrating Build Tools with CI/CD" +Linters and Formatters,Purpose of Linters and Code Formatters|Identifying Code Style Issues with Linters|Automatic Code Formatting with Formatters|Configuring ESLint Rules and Plugins|Integrating Prettier into Development Workflow|Linting and Formatting in IDEs and Pre-commit Hooks +Module Bundlers,"Understanding JavaScript Modules (ESM, CommonJS)|Why Module Bundlers are Essential|Entry Points and Output Bundles|Code Splitting and Lazy Loading|Tree Shaking for Bundle Optimization|Asset Management (CSS, Images, Fonts)|Hot Module Replacement (HMR) for Development" +Parcel,"Introduction to Parcel and Zero Configuration|Basic Project Setup and Asset Handling|Development Server and Hot Module Replacement|Handling Different Asset Types (JS, CSS, HTML, Images)|Optimizing Production Builds with Parcel|Extending Parcel with Plugins and Custom Transformers" +Rollup,"Introduction to Rollup and its Focus on Libraries|Basic Configuration for JavaScript Bundling|Tree Shaking and ES Module Optimization|Handling CommonJS and Third-Party Dependencies|Rollup Plugins for Asset Processing|Output Formats (ESM, CommonJS, UMD, IIFE)|Code Splitting and Multi-Entry Bundles" +esbuild,Introduction to esbuild and its Performance Advantages|Basic CLI Usage for Bundling and Transformation|Configuring esbuild for JavaScript and TypeScript|Transforming and Minifying Code|Bundling CSS and Other Assets|Integrating esbuild with Build Scripts and Dev Servers +Prettier,"What Prettier is and its Opinionated Formatting|Installing and Running Prettier CLI|Configuring Prettier Options (Print Width, Tabs vs. Spaces)|Integrating Prettier with IDEs and Editors|Prettier with Linting Tools (e.g., ESLint)|Automating Formatting with Pre-commit Hooks" +Vitest,"Introduction to Vitest and Vite Integration|Writing Basic Unit Tests with Vitest|Assertions and Matchers (expect API)|Mocking Functions and Modules|Testing Asynchronous Code|Test Coverage Reporting|Component Testing with Vitest (e.g., React Testing Library)" +Jest,"Introduction to Jest and its Testing Philosophy|Writing Basic Unit Tests with Jest|Assertions and Matchers (expect API)|Mocking Functions, Modules, and Timers|Testing Asynchronous Code (Promises, Async/Await)|Snapshot Testing for UI Regression|Test Coverage and Reporting|Integration Testing and End-to-End Testing Setup" +Playwright,"Introduction to Playwright and Browser Automation|Setting up Playwright for End-to-End Testing|Locating Elements and Interacting with Pages|Assertions and Waiting for Elements|Handling User Interactions (Clicks, Typing, Navigation)|Testing Across Multiple Browsers and Devices|Debugging Tests and Tracing|Integrating Playwright with CI/CD Pipelines" +Authentication Strategies,Fundamentals of Authentication vs. Authorization|Session-Based Authentication (Cookies)|Token-Based Authentication (JWT)|OAuth 2.0 and OpenID Connect|Multi-Factor Authentication (MFA)|Password Hashing and Storage Best Practices|Single Sign-On (SSO) Concepts|Authentication in SPAs and APIs +Content Security Policy,"Introduction to CSP and its Purpose|CSP Directives (script-src, style-src, default-src)|Reporting CSP Violations|Implementing CSP in Web Applications|CSP Nonces and Hashes for Inline Scripts|Strict CSP and Best Practices|Bypassing Common CSP Misconfigurations" +OWASP Security Risks,"Introduction to OWASP and the Top 10|Injection Flaws (SQL, NoSQL, Command)|Broken Authentication and Session Management|Cross-Site Scripting (XSS) Vulnerabilities|Insecure Deserialization|Security Misconfiguration|Broken Access Control|Cross-Site Request Forgery (CSRF)|Using OWASP Resources for Secure Development" +Web Components,"Introduction to Web Components Standards|Custom Elements: Defining and Registering|Shadow DOM: Encapsulation and Styling|HTML Templates: Reusable Markup|HTML Imports (Historical Context and Alternatives)|Lifecycle Callbacks of Custom Elements|Communicating with Custom Elements (Props, Events, Slots)|Building Reusable UI Libraries with Web Components" +Type Checkers,"Introduction to Static vs. Dynamic Typing|Benefits of Type Checkers in JavaScript|Basic Type Annotations (Primitives, Arrays, Objects)|Interface and Type Alias Definitions|Generics for Reusable Components|Type Inference and Type Guards|Configuring TypeScript Compiler Options|Integrating Type Checkers with Build Tools" +Custom Elements,"Introduction to Custom Elements Specification|Defining a Custom Element (Class and `customElements.define`)|Custom Element Lifecycle Callbacks (connectedCallback, disconnectedCallback)|Attributes and Properties in Custom Elements|Shadow DOM Integration for Encapsulation|Styling Custom Elements (CSS Custom Properties, ::part, ::slotted)|Communicating with Custom Elements (Events, Slots)|Extending Built-in HTML Elements" +HTML Templates,Introduction to the HTML template tag|Cloning and instantiating template content|Using slot elements for content distribution|Styling template content within the DOM|Integrating templates with JavaScript for dynamic rendering|Template use cases and best practices +Shadow DOM,"Introduction to Web Components and Encapsulation|Creating and attaching a Shadow Root (open vs. closed)|Styling Shadow DOM content (CSS variables, ::part, ::slotted)|Event handling within Shadow DOM boundaries|Shadow DOM vs. Light DOM interaction and composition|Accessibility considerations in Shadow DOM|Real-world applications of Shadow DOM" +SSR,"Understanding Client-Side vs. Server-Side Rendering|Benefits and drawbacks of SSR (SEO, performance, TTFB)|Basic SSR architecture and setup (e.g., Node.js with Express)|Hydration process and its challenges|Data fetching strategies in SSR applications|Caching mechanisms for SSR performance|Error handling and debugging in SSR environments|Framework-specific SSR implementations (e.g., Next.js, Nuxt.js)" +react-router,"Introduction to Client-Side Routing in React|Installation and basic setup (BrowserRouter, Routes, Route)|Navigating with Link and NavLink components|Dynamic routing and URL parameters (useParams)|Nested routes and layout components|Programmatic navigation with useNavigate hook|Route guards and authentication patterns|Error handling and 404 pages|Advanced features like lazy loading and data loaders" +Nuxt.js,"Introduction to Nuxt.js and the Vue.js ecosystem|Project setup and directory structure conventions|Pages and file-based routing system|Layouts and component organization|Data fetching strategies (SSR, SSG, Client-side)|State management with Pinia|Middleware and authentication flows|Deployment strategies (SSR, Static, Hybrid)|Nuxt.js module ecosystem and extensibility" +Svelte Kit,"Introduction to Svelte and SvelteKit framework|Project setup and file-based routing|Layouts and component structure|Data loading with load functions (+page.server.js, +page.js)|Form actions and data mutations|Endpoint routes (+server.js) for API creation|Error handling and redirects|Deployment targets (SSR, Static, Adapter-specific)|Advanced features like stores and hooks" +Apollo,"Introduction to GraphQL and its advantages|Setting up Apollo Client in a web application|Executing queries with useQuery hook|Performing mutations for data modification with useMutation|Managing local state with Apollo Client cache|Real-time data with GraphQL subscriptions|Error handling and loading states in Apollo|Authentication and authorization with Apollo Client|Advanced cache management (optimistic updates, pagination)" +Relay Modern,"Introduction to Relay and GraphQL principles|Relay Compiler and schema definition|Fetching data with queries and fragments|Performing mutations for data modification|Managing local state and cache updates|Pagination and connections in Relay|Subscriptions for real-time data|Error handling and loading states|Advanced features (Environment, Store, Network Layer)" +Static Site Generators,"Understanding static vs. dynamic websites|Benefits of SSGs (performance, security, cost)|Core concepts: data, templates, and build process|Choosing an SSG (e.g., Jekyll, Hugo, Eleventy, Astro)|Content management with Markdown and headless CMS|Deployment of static sites (Netlify, Vercel, GitHub Pages)|Integrating dynamic features (serverless functions, APIs)|SEO and performance optimization for static sites" +Vuepress,Introduction to VuePress and Markdown-driven documentation|Project setup and basic configuration|Markdown extensions and custom components|Theming and custom layout creation|Plugins and the VuePress ecosystem|Deployment of VuePress sites|Search functionality and SEO considerations|Integrating with Vue.js components +Astro,Introduction to Astro and its Island Architecture|Project setup and file-based routing|Astro components and UI framework integrations|Data fetching and static site generation (SSG)|Server-side rendering (SSR) with Astro|Middleware and API routes|Deployment strategies for Astro projects|Performance optimization and hydration control +Eleventy,"Introduction to Eleventy and its philosophy|Project setup and configuration|Templating languages (Nunjucks, Liquid, Handlebars, etc.)|Data management (global, directory, front matter)|Collections and pagination|Shortcodes and filters for content processing|Deployment and build process|Integrating with CSS/JS build tools" +PWAs,Introduction to Progressive Web Apps and their benefits|Web App Manifest configuration|Service Workers: caching strategies for offline access|Service Workers: enabling offline capabilities|Push notifications implementation|Add to Home Screen (A2HS) prompt|Responsive design and adaptive UI for PWAs|Performance optimization for PWAs|Auditing PWAs with Lighthouse +Mobile Apps,"Introduction to mobile app development paradigms (Native, Hybrid, Cross-Platform)|Choosing a development stack (React Native, Flutter, Swift/Kotlin)|UI/UX design principles for mobile applications|Accessing device APIs and permissions (camera, location, notifications)|Data storage and persistence (local, cloud)|Performance optimization for mobile apps|Testing and debugging mobile applications|App Store submission process (Google Play, Apple App Store)|Security considerations in mobile app development" +Ionic,"Introduction to Ionic Framework and hybrid app development|Project setup with Ionic CLI|Ionic UI components and layout|Navigation and routing within Ionic apps|Integrating with Angular, React, or Vue|Accessing native device features with Capacitor/Cordova|Theming and customization of Ionic apps|Building and deploying to iOS/Android platforms|PWA deployment with Ionic" +Desktop Apps,"Introduction to desktop application development|Choosing a framework (Electron, Tauri, Qt, WPF, Swing)|UI/UX design principles for desktop applications|Inter-Process Communication (IPC) mechanisms|Native system integrations (file system, notifications, menus)|Packaging and distribution (installers, app stores)|Performance and resource management|Security considerations for desktop apps|Auto-updates and versioning strategies" +Electron,"Introduction to Electron architecture (Chromium, Node.js, Native APIs)|Project setup and understanding Main vs. Renderer process|Inter-Process Communication (IPC) with ipcMain and ipcRenderer|Creating native menus and context menus|Working with system dialogs and notifications|Packaging and distribution with Electron Forge/Builder|Implementing auto-updates for Electron apps|Performance optimization and security best practices" +Tauri,"Introduction to Tauri and Rust-based desktop apps|Project setup and core concepts (Rust backend, Web frontend)|Communicating between frontend and Rust backend (Commands)|Accessing native system APIs via Rust crates|Bundling and distribution of Tauri apps|Security features and sandboxing|Performance optimization and binary size reduction|Custom menus and system tray integration" +PRPL Pattern,"Introduction to web performance optimization|Push critical resources for the initial route|Render the initial route as quickly as possible|Pre-cache remaining routes and assets|Lazy-load non-critical resources and routes|Tools and techniques for implementing PRPL (Webpack, Service Workers)|Measuring PRPL effectiveness (Lighthouse, Web Vitals)|Applying PRPL to different application architectures" +RAIL Model,"Introduction to user-centric performance metrics|Response: Processing events in under 50ms|Animation: Producing frames in under 10ms|Idle: Maximizing browser idle time|Load: Delivering content in under 1 second|Measuring and diagnosing performance with RAIL|Tools for RAIL analysis (Chrome DevTools, Lighthouse)|Strategies for optimizing each RAIL component|Impact of RAIL on user experience and business metrics" +Using Lighthouse,"Introduction to Web Performance and Auditing|Installing and Running Lighthouse (CLI vs. DevTools)|Understanding Lighthouse Categories (Performance, Accessibility, SEO, PWA, Best Practices)|Interpreting Lighthouse Reports and Scores|Identifying and Prioritizing Performance Bottlenecks|Actionable Recommendations and Fixes|Automating Lighthouse Audits (CI/CD Integration)" +Using DevTools,"Introduction to Browser Developer Tools|Elements Panel: Inspecting and Modifying DOM/CSS|Console Panel: Logging, Debugging JavaScript, and Interacting|Sources Panel: Debugging JavaScript with Breakpoints|Network Panel: Analyzing Network Requests and Responses|Performance Panel: Profiling Runtime Performance|Application Panel: Local Storage, Session Storage, Cookies, Service Workers|Security Panel: Inspecting Security Issues|Audits Panel (Lighthouse Integration)|Memory Panel: Detecting Memory Leaks" +Web Sockets,"Introduction to Real-time Communication and HTTP Limitations|WebSocket Protocol Handshake and Connection Establishment|Sending and Receiving Data (Text and Binary Messages)|WebSocket API (Browser and Node.js ws module)|Handling Connection Lifecycle (Open, Close, Error Events)|Error Handling and Reconnection Strategies|Security Considerations for WebSockets|Scaling WebSocket Applications" +Service Workers,"Introduction to Progressive Web Apps (PWAs) and Offline Capabilities|Service Worker Lifecycle (Registration, Installation, Activation)|Intercepting Network Requests with fetch Event|Caching Strategies (Cache-First, Network-First, Stale-While-Revalidate)|Updating Service Workers and Cache Management|Push Notifications with Service Workers|Background Sync API|Debugging Service Workers in DevTools" +Location,"Introduction to Geolocation API|Requesting User Location (getCurrentPosition)|Monitoring Location Changes (watchPosition)|Handling Geolocation Permissions and Errors|Understanding Geolocation Coordinates (Latitude, Longitude, Accuracy)|Reverse Geocoding and Geocoding Concepts|Privacy and Security Considerations for Location Data|Using Geolocation with Maps APIs" +Device Orientation,"Introduction to Device Motion and Orientation Sensors|Understanding DeviceOrientationEvent (Alpha, Beta, Gamma)|Understanding DeviceMotionEvent (Acceleration, Rotation Rate)|Handling Sensor Data and Event Listeners|Calibrating and Filtering Sensor Data|Use Cases: Games, Augmented Reality, UI Interactions|Browser Compatibility and Permissions" +Payments,"Introduction to Web Payments and Payment Request API|Understanding Payment Methods (Credit Cards, Digital Wallets)|Implementing Payment Request API (Basic Flow)|Handling Payment Responses and Errors|Integrating with Payment Gateways (Stripe, PayPal, etc.)|Security Best Practices for Online Payments (PCI DSS)|Subscription Payments and Recurring Billing|Internationalization and Currency Handling" +SWC,"Introduction to JavaScript Tooling and Transpilers (Babel vs. SWC)|SWC Installation and Basic Usage (CLI)|Configuring SWC for JavaScript/TypeScript Transpilation|SWC for Bundling (swcpack)|Integrating SWC with Build Tools (Webpack, Rollup, Vite)|SWC for Minification and Code Optimization|SWC Plugins and Custom Transformations|Performance Benefits and Comparison with other tools" +Learn a Programming Language,"Understanding Programming Paradigms (Procedural, OOP, Functional)|Basic Syntax and Data Types|Variables, Operators, and Expressions|Control Flow (Conditionals, Loops)|Functions and Modularity|Data Structures (Arrays, Objects/Maps)|Error Handling and Debugging|Input/Output Operations|Introduction to Standard Libraries/Frameworks|Writing and Running Your First Program" +JavaScript / Node.js,"JavaScript Fundamentals (Variables, Data Types, Operators)|Control Flow and Functions|Objects, Arrays, and Prototypes|Asynchronous JavaScript (Callbacks, Promises, Async/Await)|ES6+ Features (Arrow Functions, Classes, Destructuring)|Node.js Environment and npm Package Manager|File System Operations and Modules in Node.js|Building Web Servers with Node.js (Express.js)|Database Integration (MongoDB, PostgreSQL)|Testing and Debugging Node.js Applications" +Operating System,"Introduction to Operating Systems and Their Role|OS Components: Kernel, Shell, File System|Process Management and Scheduling|Memory Management (Virtual Memory, Paging)|File System Concepts (Permissions, Directories, Inodes)|Input/Output Management|Networking Fundamentals (TCP/IP, Sockets)|Security Principles in Operating Systems|Virtualization and Containerization Basics" +Ubuntu / Debian,"Introduction to Debian-based Linux Distributions|Installation and Basic Setup|Command Line Interface (CLI) Fundamentals|Package Management with APT (apt-get, apt)|User and Group Management|File System Navigation and Permissions|System Services Management (systemd)|Networking Configuration|Troubleshooting and Log Analysis|Security Best Practices" +SUSE Linux,"Introduction to SUSE Linux Distributions (openSUSE, SLES)|Installation and Initial Configuration|YaST Control Center for System Management|Package Management with Zypper and RPM|File System Layout and Permissions|User and Group Administration|System Services and Daemons|Networking Configuration|Security Hardening and SELinux/AppArmor Basics|Troubleshooting and System Monitoring" +RHEL / Derivatives,"Introduction to Red Hat Enterprise Linux and its Ecosystem (CentOS, Fedora)|Installation and Initial System Setup|Command Line Interface (CLI) Essentials|Package Management with DNF/YUM and RPM|User and Group Management|File System Hierarchy and Permissions|System Services Management (systemd)|Networking Configuration|SELinux Concepts and Management|Troubleshooting and Performance Monitoring" +FreeBSD,Introduction to FreeBSD and BSD Philosophy|Installation and Basic System Configuration|Command Line Interface (CLI) and Shell Usage|Package Management with Pkg and Ports System|File System Hierarchy and ZFS Fundamentals|User and Group Administration|System Services and rc.d Scripts|Networking Configuration|Jails and Virtualization|Kernel Configuration and Tuning +OpenBSD,"Introduction to OpenBSD and its Security Focus|Installation and Initial System Setup|Command Line Interface (CLI) and Shell Usage|Package Management with Pkg_add and Ports|File System Layout and Permissions|User and Group Management|System Services and rc.d Scripts|Networking Configuration and PF Firewall|Security Features (W^X, ASLR, pledge/unveil)|Kernel Configuration and Hardening" +NetBSD,Introduction to NetBSD and its Portability Focus|Installation and Basic System Configuration|Command Line Interface (CLI) and Shell Usage|Package Management with Pkgsrc|File System Layout and Permissions|User and Group Administration|System Services and rc.d Scripts|Networking Configuration|Kernel Configuration and Customization|Cross-Platform Development with NetBSD +Windows,Introduction to Windows Operating System Architecture|User Interface and Desktop Environment|File System (NTFS) and Permissions|Command Prompt (CMD) and PowerShell Basics|Task Manager and Process Management|Registry Editor and System Configuration|Networking Configuration and Firewall|User Account Control (UAC) and Security Features|Installing and Managing Software|Troubleshooting and Event Viewer +Terminal Knowledge,"Introduction to Command Line Interfaces (CLI)|Basic Navigation (cd, ls, pwd)|File and Directory Management (mkdir, touch, cp, mv, rm)|Input/Output Redirection and Pipes|Text Editors (Vim, Nano)|Permissions and Ownership (chmod, chown)|Environment Variables|Shell Scripting Fundamentals|Process Management (ps, kill, top)|Package Managers (apt, yum, brew)" +Process Monitoring,"Introduction to System Processes and Their States|Using ps Command for Process Information|Real-time Process Monitoring with top and htop|Understanding CPU, Memory, and Disk Usage Metrics|Identifying and Killing Processes (kill, killall)|Monitoring System Logs (journalctl, dmesg)|Network Process Monitoring (netstat, ss)|Performance Analysis Tools (perf, strace)|Setting up Monitoring Agents (Prometheus, Nagios)|Automated Alerting and Reporting" +Performance Monitoring,"Introduction to Performance Metrics (CPU, Memory, Disk I/O)|Monitoring Tools Overview (e.g., top, htop, iostat)|Application Performance Monitoring (APM) Concepts|Log Monitoring and Analysis|Alerting and Notification Systems|Distributed Tracing Fundamentals|Synthetic Monitoring vs. Real User Monitoring (RUM)|Performance Baselines and Anomaly Detection" +Networking Tools,"Basic Network Commands (ping, ipconfig/ifconfig)|Network Connectivity Troubleshooting (traceroute/tracert, nslookup/dig)|Port Scanning and Service Discovery (nmap)|Packet Sniffing and Analysis (tcpdump, Wireshark)|Network Configuration Management (netstat, route)|Bandwidth Monitoring Tools|VPN and Tunneling Utilities|Network Performance Testing Tools" +Text Manipulation,"Basic Command Line Text Viewers (cat, less, more)|Searching Text with grep and egrep|Stream Editing with sed|Text Processing with awk|Sorting and Uniquifying Text (sort, uniq)|Cutting and Pasting Text (cut, paste)|Regular Expressions for Pattern Matching|Advanced Text Processing Pipelines" +Power Shell,"PowerShell Fundamentals and Command Syntax|Working with Cmdlets and Objects|PowerShell Scripting Basics (Variables, Loops, Conditionals)|Pipeline Operations and Object Flow|Managing Files and Directories|Working with Services and Processes|Remote Management with PowerShell|Error Handling and Debugging in PowerShell Scripts|Advanced Scripting Functions and Modules" +What is and how to setup X ?,"Understanding the Purpose of Software X|Prerequisites and System Requirements for X|Installation Methods for X (Package Manager, Source, Installer)|Initial Configuration and Basic Setup of X|Verifying Installation and Basic Functionality|Common Post-Installation Steps and Best Practices|Troubleshooting Initial Setup Issues|Updating and Maintaining Software X" +Forward Proxy,"Introduction to Proxy Servers and Their Purpose|How Forward Proxies Work (Client-Side Proxying)|Use Cases for Forward Proxies (Anonymity, Caching, Filtering)|Configuring a Basic Forward Proxy (e.g., Squid)|Authentication and Access Control for Forward Proxies|Chaining Forward Proxies|Security Considerations for Forward Proxies|Monitoring and Logging Forward Proxy Traffic" +Firewall,"Introduction to Network Security and Firewalls|Types of Firewalls (Packet-Filtering, Stateful, Application Layer)|Firewall Rules and Policies (Ingress/Egress)|Common Firewall Implementations (e.g., iptables, ufw, Windows Firewall)|Configuring Basic Firewall Rules (Ports, Protocols, IP Addresses)|Network Address Translation (NAT) with Firewalls|Stateful Packet Inspection Concepts|Firewall Logging and Monitoring|Advanced Firewall Features (VPN Passthrough, IDS/IPS Integration)" +Tomcat,"Introduction to Java Servlets and JSP|Tomcat Architecture and Components (Connectors, Engine, Host, Context)|Installing and Configuring Tomcat Server|Deploying Web Applications (WAR files)|Tomcat Server Configuration (server.xml, web.xml)|Managing Tomcat Instances and Applications|Performance Tuning and Monitoring Tomcat|Security Best Practices for Tomcat|Integrating Tomcat with Web Servers (e.g., Apache HTTP Server)" +IIS,"Introduction to Web Servers and IIS Role|Installing and Configuring IIS on Windows Server|Creating and Managing Websites and Applications|Application Pools and Worker Processes|Configuring Bindings, Host Headers, and Virtual Directories|IIS Authentication and Authorization Methods|SSL/TLS Configuration in IIS|Performance Tuning and Monitoring IIS|URL Rewriting and Request Filtering" +Caching Server,"Introduction to Caching Concepts and Benefits|Types of Caching (Client-Side, Server-Side, CDN)|Common Caching Strategies (LRU, LFU, FIFO)|Implementing In-Memory Caching (e.g., Memcached, Redis)|Configuring Caching Servers for Web Applications|Cache Invalidation Strategies|Distributed Caching Architectures|Monitoring and Optimizing Cache Performance" +Load Balancer,"Introduction to High Availability and Scalability|Load Balancing Concepts and Algorithms (Round Robin, Least Connections)|Types of Load Balancers (Hardware, Software, DNS)|Configuring a Basic Software Load Balancer (e.g., Nginx, HAProxy)|Health Checks and Session Persistence|SSL Termination at the Load Balancer|Global Server Load Balancing (GSLB)|Advanced Load Balancer Features (Content Switching, DDoS Protection)" +Reverse Proxy,"Introduction to Proxy Servers and Their Purpose|How Reverse Proxies Work (Server-Side Proxying)|Use Cases for Reverse Proxies (Load Balancing, Security, Caching)|Configuring a Basic Reverse Proxy (e.g., Nginx, Apache HTTP Server)|SSL/TLS Termination at the Reverse Proxy|URL Rewriting and Request Routing|Security Enhancements with Reverse Proxies (WAF Integration)|Monitoring and Logging Reverse Proxy Traffic" +Containers,"Introduction to Virtualization vs. Containerization|Container Concepts (Images, Containers, Registries)|Docker Fundamentals (Installation, Basic Commands)|Building Custom Docker Images (Dockerfiles)|Managing Docker Containers and Volumes|Container Networking Basics|Container Orchestration Introduction (e.g., Docker Compose)|Container Security Best Practices" +Cloud Providers,"Introduction to Cloud Computing Concepts (IaaS, PaaS, SaaS)|Benefits and Challenges of Cloud Adoption|Major Cloud Providers Overview (AWS, Azure, GCP)|Cloud Service Models and Pricing Structures|Cloud Deployment Models (Public, Private, Hybrid)|Cloud Security Fundamentals|Cost Management and Optimization in the Cloud|Vendor Lock-in and Multi-Cloud Strategies" +Google Cloud,"Google Cloud Platform (GCP) Core Services Overview|Identity and Access Management (IAM) in GCP|Compute Services (Compute Engine, GKE, Cloud Functions)|Storage Services (Cloud Storage, Cloud SQL, Firestore)|Networking in GCP (VPC, Load Balancing, DNS)|Deployment and Management Tools (Cloud Deployment Manager, Cloud Build)|Monitoring and Logging (Cloud Monitoring, Cloud Logging)|Cost Management and Billing in GCP" +Digital Ocean,"Introduction to DigitalOcean Platform and Offerings|Creating and Managing Droplets (Virtual Machines)|Networking in DigitalOcean (VPC, Load Balancers, Firewalls)|Storage Options (Block Storage, Spaces Object Storage)|Managed Databases and Kubernetes Service (DOKS)|Deploying Applications with App Platform|Monitoring and Alerting with DigitalOcean|Billing and Account Management" +Alibaba Cloud,"Introduction to Alibaba Cloud Ecosystem and Global Infrastructure|Elastic Compute Service (ECS) and Instance Management|Networking Services (VPC, SLB, CDN)|Storage Services (OSS, ApsaraDB)|Identity and Access Management (RAM)|Deployment and Automation Tools (Resource Orchestration Service)|Monitoring and Logging (CloudMonitor, Log Service)|Cost Management and Billing in Alibaba Cloud" +Hetzner,"Introduction to Hetzner Online Offerings (Dedicated Servers, Cloud)|Ordering and Managing Dedicated Servers|Hetzner Cloud: Creating and Managing Servers (CX Series)|Networking in Hetzner Cloud (Private Networks, Floating IPs)|Storage Options (Block Storage, Snapshots)|DNS Management and Domain Services|Monitoring and Server Administration Tools|Billing and Account Management" +Heroku,"Introduction to Heroku Platform as a Service (PaaS)|Heroku CLI and Git Deployment Workflow|Dynos, Processes, and Scaling Applications|Add-ons for Databases, Caching, and Other Services|Config Vars for Environment Variables|Heroku Pipelines for CI/CD|Logging and Monitoring on Heroku|Custom Domains and SSL Configuration" +Contabo,"Introduction to Contabo Services (VPS, Dedicated Servers)|Ordering and Setting Up VPS/Dedicated Servers|Operating System Installation and Management|Server Control Panel (e.g., cPanel, Plesk) Integration|Networking Configuration and IP Management|Storage Options and Backups|Security Best Practices for Contabo Servers|Billing and Customer Support" +AWS CDK,"Introduction to Infrastructure as Code (IaC) and AWS CDK|CDK Constructs, Stacks, and Apps|CDK Languages (TypeScript/Python) and Project Setup|Defining AWS Resources with CDK Constructs|CDK Deployments, Diffing, and Synth|Advanced Constructs and Patterns (e.g., AWS Solutions Constructs)|Testing CDK Applications (Unit, Integration)|CDK Pipelines for CI/CD Automation" +CloudFormation,"Introduction to CloudFormation and IaC Principles|CloudFormation Template Structure (YAML/JSON)|Resource Declarations and Properties|Parameters, Mappings, and Conditions|Outputs and Cross-Stack References|Change Sets and Stack Updates|Nested Stacks and StackSets|Custom Resources and Macros" +Pulumi,"Introduction to Pulumi and IaC with General-Purpose Languages|Pulumi Project Structure and State Management|Defining Cloud Resources (AWS, Azure, GCP) with Pulumi|Pulumi Programming Models (e.g., TypeScript, Python)|Stack Management and Deployments (pulumi up, preview, destroy)|Input/Output Properties and Cross-Stack References|Testing Pulumi Programs|Pulumi Automation API for CI/CD Integration" +Configuration Management,Introduction to Configuration Management Principles and Benefits|Idempotency and Desired State Configuration|Agent-based vs. Agentless Configuration Management|Version Control for Configuration Files|Managing Operating System Configurations|Application Deployment and Configuration|Secrets Management in Configuration Management|Compliance and Auditing with Configuration Management +Chef,"Introduction to Chef Architecture (Workstation, Server, Node)|Chef Resources and Recipes|Cookbooks and Run Lists|Attributes and Templates|Chef Supermarket and Community Cookbooks|Roles and Environments|Data Bags for Dynamic Configuration|Chef InSpec for Compliance and Auditing" +Puppet,"Introduction to Puppet Architecture (Master, Agent, Catalog)|Puppet Resources and Manifests|Puppet Modules and Classes|Facts and Templates|Puppet Forge and Community Modules|Node Classifications and Hiera for Data Management|Puppet Environments|Puppet Bolt for Orchestration" +CI / CD Tools,"Introduction to CI/CD Principles and Benefits|Version Control System Integration (Git)|Automated Build Processes|Automated Testing (Unit, Integration, E2E)|Artifact Management and Repository|Deployment Strategies (Blue/Green, Canary, Rolling)|Pipeline Orchestration and Workflow Design|Monitoring and Feedback Loops in CI/CD" +GitLab CI,"Introduction to GitLab CI/CD Concepts|`.gitlab-ci.yml` Syntax and Structure|Jobs, Stages, and Pipelines|GitLab Runners (Shared, Specific, Docker)|Variables and Caching|Artifacts and Dependencies|Deployment to Environments|Advanced Features (Child Pipelines, Rules, DAST/SAST)" +Travis CI,Introduction to Travis CI and GitHub Integration|`.travis.yml` Configuration File Structure|Build Lifecycle and Stages|Environment Variables and Caching|Testing and Deployment Configuration|Matrix Builds for Multiple Environments|Notifications and Integrations|Customizing Build Environments +Circle CI,"Introduction to CircleCI Concepts and Workflows|`.circleci/config.yml` Structure (Jobs, Workflows)|Executors (Docker, Machine, macOS)|Caching and Workspaces|Orbs for Reusable Configuration|Contexts for Environment Variables and Secrets|Deployment Strategies and Integrations|Advanced Workflow Orchestration" +Drone,Introduction to Drone CI/CD and Container-Native Pipelines|`.drone.yml` Syntax and Pipeline Steps|Drone Runners and Execution Environments|Plugins for Common CI/CD Tasks|Secrets Management in Drone|Conditional Steps and Matrix Builds|Deployment Strategies|Extending Drone with Custom Plugins +TeamCity,"Introduction to TeamCity Architecture (Server, Agents)|Projects, Build Configurations, and VCS Roots|Build Steps and Runners|Triggers and Dependencies|Artifacts and Build Chains|Parameters and Agent Requirements|Templates and Meta-Runners for Reusability|Integrations and Reporting" +Secret Management,"Introduction to Secret Management Principles and Risks|Types of Secrets (API keys, Passwords, Certificates)|Secure Storage and Access Control|Encryption and Key Management|Rotation and Revocation of Secrets|Integration with Applications and CI/CD Pipelines|Auditing and Compliance for Secret Access|Dynamic Secret Generation" +Sealed Secrets,"Introduction to Kubernetes Secrets and their Limitations|Overview of Sealed Secrets and its Purpose|Installation and Configuration of `kubeseal` Controller|Encrypting Kubernetes Secrets with `kubeseal`|Deploying Sealed Secrets to Kubernetes Clusters|Managing Sealed Secrets Lifecycle (Updates, Deletion)|Role-Based Access Control (RBAC) for Sealed Secrets|Integration with GitOps Workflows" +Cloud Specific Tools,"Understanding Cloud Provider Ecosystems (AWS, Azure, GCP)|Cloud Provider CLI Tools (e.g., AWS CLI, Azure CLI, gcloud CLI)|Cloud Provider SDKs for Programming Languages|Infrastructure as Code (IaC) Tools (e.g., CloudFormation, ARM Templates)|Monitoring and Logging Tools (e.g., CloudWatch, Azure Monitor)|Security and Compliance Tools (e.g., GuardDuty, Security Center)|Serverless and Container Orchestration Tools|Cost Management and Optimization Tools" +Vault,"Introduction to HashiCorp Vault and its Core Concepts|Vault Architecture (Server, Storage Backend, Listener)|Installation and Initializing Vault|Authentication Methods (Token, AppRole, AWS IAM)|Secret Engines (Key/Value, AWS, Databases, PKI)|Policies and Access Control (ACLs)|Leasing, Renewal, and Revocation|Vault Agent and Integration with Applications" +SOPs,"Introduction to Standard Operating Procedures (SOPs) and their Importance|Purpose and Benefits of Documenting Procedures|Components of a Well-Structured SOP|SOP Development Process (Drafting, Review, Approval)|Version Control and Document Management for SOPs|Training and Adherence to SOPs|Auditing and Updating SOPs|Integrating SOPs into Incident Response and Change Management" +Infrastructure Monitoring,"Introduction to Infrastructure Monitoring Principles and Goals|Key Metrics to Monitor (CPU, Memory, Disk I/O, Network)|Monitoring Agent Deployment and Configuration|Alerting and Notification Mechanisms|Dashboarding and Visualization of Metrics|Log Management and Analysis Integration|Distributed Tracing Concepts|Capacity Planning and Performance Optimization" +Zabbix,"Introduction to Zabbix Architecture (Server, Agent, Proxy)|Installation and Initial Configuration of Zabbix Server|Zabbix Agents and Agentless Monitoring|Items, Triggers, and Graphs|Templates and Host Groups|Actions, Alerts, and Escalations|Low-Level Discovery (LLD) for Dynamic Monitoring|Zabbix API and Custom Scripting" +Prometheus,"Introduction to Prometheus Architecture and Data Model|Prometheus Server Installation and Configuration|Exporters for Collecting Metrics (Node Exporter, cAdvisor)|PromQL (Prometheus Query Language) for Data Analysis|Alertmanager for Alerting and Notifications|Grafana Integration for Dashboarding|Service Discovery Mechanisms (Static, File, Kubernetes)|Federation and Remote Storage" +Grafana,"Introduction to Observability and Monitoring|Grafana Installation and Configuration|Data Sources Integration (Prometheus, InfluxDB, Loki)|Dashboard Creation and Visualization Types|Alerting and Notification Setup|Templating and Variables|Advanced Panel Options and Transformations|Grafana Security and User Management" +Logs Management,"Introduction to Logging Concepts and Importance|Log Collection Agents (Fluentd, Filebeat, rsyslog)|Log Aggregation and Centralization|Log Parsing and Structured Logging|Log Storage Solutions (Elasticsearch, Loki, Splunk)|Log Search and Filtering Techniques|Log Visualization and Dashboards|Alerting on Log Patterns and Anomalies|Log Retention Policies and Compliance" +Elastic Stack,"Introduction to ELK Stack Components (Elasticsearch, Logstash, Kibana)|Elasticsearch Fundamentals (Indexing, Documents, Queries)|Logstash for Data Ingestion and Transformation|Kibana for Data Visualization and Dashboards|Beats for Data Collection (Filebeat, Metricbeat, Heartbeat)|Elastic Stack Security and X-Pack Features|Scaling and Performance Tuning|Monitoring the Elastic Stack" +Graylog,"Introduction to Centralized Log Management with Graylog|Graylog Installation and Setup (MongoDB, Elasticsearch)|Input Configuration (Syslog, GELF, Beats)|Streams and Message Routing|Extractors and Data Parsing|Search and Query Language|Dashboards and Widgets for Visualization|Alerts and Notifications|User and Role Management" +Papertrail,"Introduction to Cloud-based Log Management|Papertrail Account Setup and Configuration|Log Sender Configuration (syslog-ng, rsyslog, remote_syslog2)|Log Search and Filtering Syntax|Event Viewer and Live Tail|Alerts and Integrations (Slack, PagerDuty)|Groups and Log Aggregation|Archives and Exporting Logs" +Container Orchestration,"Introduction to Containers and Microservices|Challenges of Managing Containers at Scale|Core Concepts of Container Orchestration (Scheduling, Scaling, Networking)|Container Orchestration Platforms Overview (Kubernetes, Docker Swarm)|Deployment Strategies (Rolling Updates, Blue/Green)|Service Discovery and Load Balancing|Persistent Storage for Containers|Monitoring and Logging in Orchestrated Environments|Security Best Practices for Container Orchestration" +GKE / EKS / AKS,"Introduction to Managed Kubernetes Services|Cloud Provider Specifics (GCP, AWS, Azure)|Cluster Creation and Configuration|Node Pools and Scaling Strategies|Networking in Managed Kubernetes (VPC, CNI)|Storage Options (Persistent Volumes, Storage Classes)|Identity and Access Management (IAM Integration)|Monitoring, Logging, and Cost Management|Upgrades and Maintenance of Managed Clusters" +AWS ECS / Fargate,"Introduction to AWS Container Services|ECS Concepts (Clusters, Tasks, Services, Containers)|Task Definitions and Container Configuration|Service Creation and Load Balancer Integration|Fargate Launch Type vs. EC2 Launch Type|Networking Modes (awsvpc, bridge, host)|Service Discovery with Cloud Map|Monitoring and Logging with CloudWatch|Deployment Strategies and Rollbacks" +Docker Swarm,Introduction to Docker Swarm Mode|Swarm Cluster Initialization and Node Management|Creating and Managing Services|Scaling Services and Replicas|Overlay Networking for Services|Service Discovery and Load Balancing|Persistent Storage with Volumes|Updating and Rolling Back Services|Monitoring Swarm Services +Artifact Management,"Introduction to Software Artifacts and Their Lifecycle|Importance of Centralized Artifact Repositories|Types of Artifacts (Maven, npm, Docker images, NuGet)|Repository Concepts (Local, Remote, Virtual)|Version Control for Artifacts|Build Tool Integration (Maven, Gradle, npm, Docker)|Security and Access Control for Repositories|Retention Policies and Cleanup|High Availability and Disaster Recovery" +Artifactory,"Introduction to JFrog Artifactory Features|Artifactory Installation and Setup|Repository Configuration (Maven, npm, Docker, Generic)|Proxying Remote Repositories|Virtual Repositories for Unified Access|User and Permission Management|Build Integration and Metadata Capture|Security Scans with Xray Integration|High Availability and Disaster Recovery" +Nexus,"Introduction to Sonatype Nexus Repository Manager|Nexus Installation and Initial Configuration|Repository Types (Maven, npm, Docker, Raw)|Proxying External Repositories|Group Repositories for Consolidated Access|User Authentication and Role-Based Access Control|Build Tool Integration|Cleanup Policies and Storage Management|High Availability and Backup Strategies" +Cloud Smith,"Introduction to Cloud-Native Package Management|CloudSmith Account Setup and Repository Creation|Package Upload and Publishing (Maven, npm, Docker, PyPI)|Repository Access Control and Permissions|Integration with CI/CD Pipelines|Webhooks and Notifications|Usage Analytics and Reporting|Security Scanning and Vulnerability Management|Global Distribution and CDN Integration" +GitOps,"Introduction to Git as the Single Source of Truth|Core Principles of GitOps (Declarative, Versioned, Pulled, Automated)|Infrastructure as Code (IaC) with Git|Continuous Delivery with GitOps|GitOps Operators (ArgoCD, FluxCD)|Pull Request-based Workflows|Rollbacks and Auditing with Git History|Security Considerations in GitOps|Implementing GitOps for Kubernetes" +ArgoCD,Introduction to ArgoCD for Kubernetes GitOps|ArgoCD Installation and Setup|Applications and ApplicationSets|Connecting Git Repositories|Synchronization and Health Checks|Rollbacks and History Management|Resource Exclusions and Overrides|Authentication and Authorization|Advanced Sync Options and Hooks +FluxCD,"Introduction to FluxCD for GitOps on Kubernetes|FluxCD Installation and Bootstrap|Source Controllers (GitRepository, HelmRepository)|Kustomization and HelmRelease Controllers|Image Automation (ImageRepository, ImagePolicy)|Multi-tenancy and Access Control|Notifications and Alerts|Rollbacks and Reconciliation|Integrating with CI Pipelines" +Istio,"Introduction to Service Meshes and Their Benefits|Istio Architecture (Control Plane, Data Plane - Envoy)|Istio Installation and Setup|Traffic Management (Routing, Load Balancing, Retries)|Traffic Shifting and Canary Deployments|Policy Enforcement (Authentication, Authorization)|Observability (Metrics, Tracing, Logging)|Security (mTLS, Authorization Policies)|Advanced Features (Gateways, Virtual Services, Sidecars)" +Consul,"Introduction to Service Discovery and Configuration Management|Consul Architecture (Agents, Servers, Clients)|Consul Installation and Cluster Setup|Service Registration and Health Checks|Key-Value Store for Dynamic Configuration|Consul DNS Interface|Consul Connect for Service Mesh Capabilities|ACLs and Security|Integrating Consul with Applications and Infrastructure" +Linkerd,"Introduction to Lightweight Service Meshes|Linkerd Architecture (Control Plane, Data Plane - Proxy)|Linkerd Installation and Injecting Proxies|Traffic Management (Retries, Timeouts, Load Balancing)|Observability (Metrics, Tracing, Top-line Metrics)|Security (mTLS, Authorization Policies)|Debugging and Troubleshooting with Linkerd CLI|Traffic Split for Canary Deployments|Integrating Linkerd with Kubernetes" +Envoy,"Introduction to High-Performance Proxy and Service Mesh Data Plane|Envoy Architecture and Core Concepts (Listeners, Filters, Clusters)|Envoy Configuration Language (YAML/JSON)|Traffic Management (Routing, Load Balancing, Retries)|Observability Features (Metrics, Tracing, Access Logging)|Security Features (TLS, Authentication Filters)|Dynamic Configuration with xDS API|Extending Envoy with Filters|Using Envoy as an Edge Proxy or Sidecar" +Cloud Design Patterns,Introduction to Cloud Computing Challenges|Overview of Common Cloud Design Patterns|Resiliency and Fault Tolerance Patterns|Scalability and Performance Patterns|Data Management and Consistency Patterns|Security and Identity Patterns|Deployment and Operations Patterns|Choosing and Applying Patterns in Practice +Availability,"Definition of Availability and Key Metrics (SLAs, SLOs)|Redundancy Strategies (N+1, Active-Passive, Active-Active)|Fault Tolerance Mechanisms (Retries, Circuit Breakers)|Disaster Recovery Planning (RTO, RPO)|High Availability Architectures (Load Balancing, Clustering)|Monitoring and Alerting for Availability|Chaos Engineering and Resilience Testing" +Design and Implementation,"Requirements Gathering and Analysis|System Architecture Principles (Modularity, Scalability)|Software Design Patterns and Principles (SOLID, GRASP)|Data Modeling and Database Design|API Design and Integration Strategies (REST, GraphQL)|Version Control Systems (Git) and Workflows|Testing Strategies (Unit, Integration, End-to-End)|Deployment and Release Management|Code Quality and Refactoring Techniques" +Management and Monitoring,"Introduction to IT Operations and Management|Monitoring Fundamentals (Metrics, Logs, Traces)|Alerting, Notification, and Incident Management|Change Management Processes|Configuration Management (e.g., Ansible, Puppet)|Performance Management and Optimization|Capacity Planning and Resource Management|Security Operations and Compliance Monitoring|Automation in IT Operations (Scripting, Runbooks)" +Loki,"Introduction to Log Management and Observability|Loki Architecture and Components (Distributor, Ingester, Querier)|Log Collection with Promtail and Agents|Log Querying with LogQL Syntax and Operators|Labeling Best Practices for Logs|Alerting from Loki Logs using Rulers|Integrating Loki with Grafana for Visualization|Scaling and Operating Loki in Production" +GCP Functions,"Introduction to Serverless Computing and FaaS|GCP Functions Concepts and Use Cases|Writing and Deploying HTTP-triggered Functions|Event-driven Functions (Cloud Storage, Pub/Sub)|Function Configuration and Environment Variables|Managing Dependencies and Runtimes|Testing and Debugging GCP Functions|Monitoring and Logging with Cloud Monitoring|Security Best Practices for GCP Functions" +Application Monitoring,"Introduction to Observability vs. Monitoring|Key Monitoring Pillars: Metrics, Logs, Traces|Types of Application Monitoring (APM, RUM, Synthetic)|Collecting Application Metrics and Performance Indicators|Structured Logging and Log Aggregation|Distributed Tracing Concepts and Implementation|Alerting Strategies and Incident Response|Dashboarding and Visualization of Application Health|Performance Analysis and Optimization Techniques" +Jaeger,"Introduction to Distributed Tracing and its Importance|Jaeger Architecture and Components (Agent, Collector, Query)|Instrumenting Applications for Tracing (OpenTracing/OpenTelemetry)|Understanding Spans, Traces, and Context Propagation|Deploying and Configuring Jaeger|Querying and Analyzing Traces in Jaeger UI|Integrating Jaeger with Service Meshes|Best Practices for Trace Annotation and Tagging" +New Relic,"Introduction to Application Performance Monitoring (APM)|New Relic Platform Overview (APM, Browser, Infrastructure)|Installing and Configuring New Relic Agents|Understanding Key Metrics and Dashboards in APM|Transaction Tracing and Error Analysis|Browser Monitoring (RUM) and Synthetic Monitoring|Infrastructure Monitoring and Host Metrics|Log Management and Correlation|Alerting and NRQL (New Relic Query Language)" +OpenTelemetry,"Introduction to Observability Standards and Vendor Neutrality|OpenTelemetry Architecture (APIs, SDKs, Collectors)|Instrumenting Applications for Traces (Spans, Context)|Instrumenting Applications for Metrics (Counters, Gauges)|Instrumenting Applications for Logs (Log Records, Attributes)|OpenTelemetry Collector Configuration and Processing|Exporting Telemetry Data to Various Backends|Semantic Conventions for Standardized Data|Integrating OpenTelemetry with Existing Systems" +Fundamental IT Skills,"Basic Computer Operation and File Management|Internet Navigation and Web Browser Usage|Email Communication and Etiquette|Word Processing and Spreadsheet Software Basics|Data Backup and Recovery Fundamentals|Basic Cybersecurity Practices (Passwords, Phishing)|Introduction to Operating Systems (Windows, macOS, Linux)|Basic Troubleshooting Methodologies|Understanding Common IT Terminology" +Computer Hardware Components,"Introduction to Computer Systems and Architecture|Central Processing Unit (CPU) and its Functions|Random Access Memory (RAM) Types and Purpose|Storage Devices (HDDs, SSDs, NVMe)|Motherboard and Chipset Functions|Graphics Processing Unit (GPU) and Video Output|Power Supply Unit (PSU) and Power Delivery|Input/Output Devices and Peripherals|Expansion Cards and Ports (PCIe, USB, HDMI)" +Connection Types and their function,"USB (Universal Serial Bus) Types and Versions|Video Output Ports (HDMI, DisplayPort, VGA)|Ethernet (RJ45) for Wired Networking|Audio Jacks and Optical Audio|Power Connectors (AC, DC Barrel, SATA Power)|Internal Data Connectors (SATA, PCIe, M.2)|Wireless Connection Overview (Wi-Fi, Bluetooth, NFC)|Thunderbolt and USB-C Multifunctionality|Understanding Port Speeds and Bandwidth" +OS-Independent Troubleshooting,"Introduction to Troubleshooting Methodologies|Identifying the Problem and Gathering Information|Formulating Hypotheses and Testing Solutions|Basic Hardware Diagnostics (POST codes, Beep codes)|Network Connectivity Checks (Ping, Tracert)|Power Cycle and Rebooting Techniques|Checking Physical Connections and Cables|Resource Utilization Monitoring Concepts|Driver and Firmware Update Concepts" +Understand Basics of Popular Suites,"Introduction to Productivity Software Suites|Word Processing Fundamentals (e.g., Microsoft Word, Google Docs)|Spreadsheet Software Basics (e.g., Microsoft Excel, Google Sheets)|Presentation Software Essentials (e.g., PowerPoint, Google Slides)|Email Client Usage and Management (e.g., Outlook, Gmail)|Cloud Storage and Collaboration Features|Basic File Sharing and Permissions|Common File Formats and Compatibility" +Basics of Computer Networking,"Definition of a Network and its Components|Network Topologies (Star, Bus, Ring)|OSI Model and TCP/IP Model Overview|IP Addressing (IPv4, IPv6) and Subnetting Concepts|Network Devices (Routers, Switches, Hubs)|Common Protocols (TCP, UDP, HTTP, DNS, DHCP)|Client-Server Architecture|Basic Network Security Concepts (Firewalls, VPNs)|Wireless Networking Fundamentals" +NFC,"Introduction to Short-Range Wireless Technologies|NFC Principles and Operating Frequencies|NFC Modes of Operation (Reader/Writer, Peer-to-Peer)|NFC Tags and Data Formats (NDEF)|Common NFC Use Cases (Contactless Payments, Pairing)|Security Considerations for NFC|NFC Device Compatibility and Setup|Troubleshooting NFC Connectivity" +WiFi,"Introduction to Wireless Local Area Networks (WLANs)|WiFi Standards and Generations (802.11a/b/g/n/ac/ax)|WiFi Frequencies (2.4 GHz, 5 GHz, 6 GHz) and Channels|WiFi Network Components (Access Points, Routers)|SSID, Passwords, and Basic Security (WPA2, WPA3)|Understanding Signal Strength and Interference|Setting up a Basic WiFi Network|Troubleshooting WiFi Connectivity Issues|WiFi Security Best Practices" +Bluetooth,"Introduction to Personal Area Networks (PANs)|Bluetooth Core Specification and Versions|Bluetooth Profiles and Protocols (A2DP, HFP, GATT)|Bluetooth Pairing and Connection Process|Bluetooth Low Energy (BLE) vs. Classic Bluetooth|Common Bluetooth Devices and Use Cases|Troubleshooting Bluetooth Connectivity|Bluetooth Security Considerations|Range, Interference, and Power Consumption" +Infrared,"Introduction to Infrared Communication Principles|Infrared Spectrum and Wavelengths|Line-of-Sight Communication Requirement|Common Infrared Use Cases (Remote Controls, IrDA)|Advantages and Limitations of Infrared|Infrared Data Association (IrDA) Standard|Security Aspects of Infrared Communication|Comparison with other Wireless Technologies" +iCloud,"Introduction to iCloud and its Purpose|iCloud Storage Plans and Management|iCloud Backup and Restore for iOS/macOS|iCloud Drive for File Syncing and Sharing|iCloud Photos and Photo Library Management|iCloud Mail, Contacts, Calendars, and Reminders|Find My Devices and Items|iCloud Keychain for Password Management|iCloud Security and Privacy Features|Family Sharing with iCloud" +Google Suite,Introduction to Google Workspace Applications|Gmail: Email Management and Organization|Google Calendar: Scheduling and Event Management|Google Drive: Cloud Storage and File Sharing|Google Docs: Word Processing and Collaboration|Google Sheets: Spreadsheet Creation and Data Analysis|Google Slides: Presentation Design and Delivery|Google Meet: Video Conferencing and Online Meetings|Google Forms: Surveys and Data Collection|Google Sites: Basic Website Creation +MS Office Suite,"Introduction to Microsoft 365 and Core Applications|Microsoft Word: Document Creation and Formatting|Microsoft Excel: Spreadsheet Fundamentals and Data Manipulation|Microsoft PowerPoint: Presentation Design and Delivery|Microsoft Outlook: Email, Calendar, and Contact Management|Microsoft OneNote: Digital Note-Taking and Organization|Microsoft Teams: Collaboration and Communication|OneDrive: Cloud Storage and File Sharing|Advanced Excel Functions and Data Analysis|Integrating Office Applications for Workflow Efficiency" +HackTheBox,"Introduction to HackTheBox Platform and Rules of Engagement|Basic Linux Command Line Interface for Penetration Testing|Network Scanning and Enumeration with Nmap and Gobuster|Web Application Vulnerabilities (OWASP Top 10 Basics)|Exploitation Techniques (Metasploit Basics, Common Exploits)|Linux and Windows Privilege Escalation Techniques|Post-Exploitation and Lateral Movement|Reporting and Documentation of Findings|Active Directory Exploitation Fundamentals|CTF Methodology and Advanced Problem Solving" +TryHackMe,"Introduction to TryHackMe Platform and Learning Paths|Basic Linux Fundamentals for Hacking|Networking Basics for Penetration Testing|Web Application Basics and Common Vulnerabilities|Introduction to Cryptography and Hashing|Basic Exploitation Techniques (e.g., Buffer Overflows, SQL Injection)|Windows and Linux Privilege Escalation Fundamentals|Introduction to Digital Forensics and Incident Response|Malware Analysis Basics|CTF Walkthroughs and Guided Learning" +VulnHub,"Introduction to VulnHub and Virtual Machine Setup|Basic Network Reconnaissance and Scanning with Nmap|Web Application Enumeration and Directory Brute-Forcing|Common Web Vulnerabilities (SQLi, LFI, RFI, Command Injection)|Exploiting Services (FTP, SSH, SMB, HTTP)|Linux Privilege Escalation Techniques (Kernel Exploits, SUID, SUDO)|Windows Privilege Escalation Techniques (Service Exploits, UAC Bypass)|Post-Exploitation and Data Exfiltration|Custom Exploit Development Basics|Developing a CTF Methodology for VulnHub VMs" +picoCTF,"Introduction to picoCTF Platform and Challenge Categories|Basic Command Line Interface and File System Navigation|Cryptography Fundamentals (Caesar, Vigenere, RSA Basics)|Binary Exploitation Basics (Stack Overflows, Shellcoding)|Web Exploitation Fundamentals (XSS, SQLi, Directory Traversal)|Forensics Basics (Steganography, File Analysis)|Reverse Engineering Fundamentals (Disassembly, Debugging)|Scripting for CTFs (Python for Automation)|Network Analysis with Wireshark Basics|Advanced CTF Problem Solving Strategies" +SANS Holiday Hack Challenge,Introduction to the SANS Holiday Hack Challenge and Storyline|Basic Linux Command Line and Networking Concepts|Web Application Security Fundamentals|Introduction to Digital Forensics and Incident Response|Basic Cryptography and Steganography|Cloud Security Concepts (AWS/Azure Basics)|Open-Source Intelligence (OSINT) Techniques|Reverse Engineering and Malware Analysis Basics|Container Security Fundamentals (Docker Basics)|Advanced Problem Solving and Critical Thinking for CTFs +CompTIA A+,"Introduction to IT Fundamentals and Hardware Components|Operating System Installation and Configuration (Windows, macOS, Linux)|Networking Fundamentals (TCP/IP, OSI Model, Network Devices)|Mobile Devices and Troubleshooting|Hardware Troubleshooting and Repair|Software Troubleshooting and Problem Resolution|Security Fundamentals (Malware, Social Engineering, Basic Protections)|Operational Procedures (Documentation, Safety, Environmental)|Virtualization and Cloud Computing Basics|Scripting Basics and Remote Access" +CompTIA Linux+,"Linux Installation and Configuration|GNU and Unix Commands (File Management, Text Processing)|Shell Scripting and Automation (Bash)|Linux Filesystems and Storage Management|Networking Configuration and Troubleshooting|System Services and Process Management|Security Fundamentals (Permissions, Users, Firewalls)|Virtualization and Containerization (Docker Basics)|Troubleshooting and Performance Monitoring|Advanced System Administration Tasks" +CompTIA Network+,"Networking Concepts (OSI Model, TCP/IP Suite)|Network Topologies and Architectures|Network Devices (Routers, Switches, Firewalls, APs)|Cabling and Connectivity Standards|IP Addressing and Subnetting (IPv4, IPv6)|Network Protocols and Services (DNS, DHCP, HTTP, FTP)|Wireless Networking Standards and Security|Network Security Fundamentals (Threats, Vulnerabilities, Controls)|Network Troubleshooting Tools and Methodologies|Cloud and Virtualization in Networking" +CCNA,"Introduction to Networking and Cisco Devices|Network Fundamentals (OSI, TCP/IP, Ethernet)|IP Addressing and Subnetting (IPv4, IPv6)|Cisco IOS Command Line Interface (CLI)|Switching Concepts (VLANs, STP, EtherChannel)|Routing Concepts (Static, OSPF, EIGRP)|Network Security Fundamentals (ACLs, VPNs, Firewalls)|Wireless LAN Concepts and Configuration|Network Automation and Programmability Basics|WAN Technologies and Services" +CompTIA Security+,"Threats, Attacks, and Vulnerabilities (Malware, Social Engineering, Exploits)|Architecture and Design (Enterprise Security, Cloud Security, Virtualization)|Implementation (Secure Protocols, PKI, Wireless Security)|Operations and Incident Response (Forensics, Disaster Recovery, SIEM)|Governance, Risk, and Compliance (Policies, Regulations, Frameworks)|Cryptography Fundamentals and Implementations|Identity and Access Management (Authentication, Authorization)|Application Security Best Practices|Physical Security Controls|Security Assessment and Testing" +CEH,Introduction to Ethical Hacking and Information Security|Footprinting and Reconnaissance Techniques|Network Scanning and Enumeration|Vulnerability Analysis and System Hacking|Malware Threats and Analysis|Sniffing and Social Engineering|Denial of Service (DoS) and Session Hijacking|Web Server and Web Application Hacking|Wireless Network Hacking|Cloud Computing Security and IoT Hacking +CISA,"The Process of Auditing Information Systems|Governance and Management of IT|Information Systems Acquisition, Development, and Implementation|Information Systems Operations and Business Resilience|Protection of Information Assets|IT Audit Standards and Guidelines|Risk Management and Control Frameworks|Business Continuity and Disaster Recovery Planning|Legal, Regulatory, and Compliance Issues|Emerging Technologies and Audit Implications" +CISM,"Information Security Governance|Information Security Risk Management|Information Security Program Development and Management|Information Security Incident Management|Legal, Regulatory, and Compliance Issues in Security|Security Metrics and Reporting|Business Continuity and Disaster Recovery Planning|Security Awareness and Training Programs|Vendor and Third-Party Risk Management|Emerging Technologies and Security Implications" +GSEC,"Introduction to Information Security and Core Concepts|Network Security Fundamentals (TCP/IP, Firewalls, IDS/IPS)|Operating System Security (Windows, Linux)|Cryptography Basics and Application|Defensive Security Technologies and Practices|Incident Handling and Response Fundamentals|Vulnerability Management and Penetration Testing Basics|Cloud Security Fundamentals|Secure Communications and VPNs|Security Policy and Awareness" +GPEN,Introduction to Penetration Testing Methodologies|Advanced Network Reconnaissance and Scanning|Exploiting Windows and Linux Systems|Web Application Penetration Testing|Password Attacks and Cracking Techniques|Post-Exploitation and Privilege Escalation|Wireless Penetration Testing|Reporting and Remediation Strategies|Exploit Development and Custom Shellcode|Advanced Red Teaming Techniques +GWAPT,"Web Application Architecture and Technologies|OWASP Top 10 Vulnerabilities (Injection, XSS, CSRF)|Web Application Reconnaissance and Mapping|Authentication and Session Management Attacks|Input Validation and Encoding Issues|File Upload Vulnerabilities and Exploitation|API Security Testing|Client-Side Attacks (DOM XSS, Clickjacking)|Advanced Web Application Exploitation Techniques|Web Application Penetration Testing Methodologies and Reporting" +GIAC,"Introduction to GIAC Certifications and Domains|Information Security Fundamentals and Principles|Cybersecurity Career Paths and Specializations|Understanding Different Security Domains (Offensive, Defensive, Forensics)|GIAC Certification Exam Preparation Strategies|Continuous Learning and Professional Development in Cybersecurity|Industry Standards and Best Practices (NIST, ISO 27001)|Threat Intelligence and Analysis|Incident Response and Digital Forensics Overview|Security Architecture and Engineering Principles" +Validation,"Introduction to Data Validation Concepts|Types of Validation (Client-Side vs. Server-Side)|Implementing Basic Validation Rules and Constraints|Error Handling and User Feedback Mechanisms|Advanced Validation Patterns (e.g., Cross-Field, Asynchronous)|Testing and Debugging Validation Logic|Internationalization of Validation Messages" +Iterative Process,"Fundamentals of Iterative Development|Phases of an Iteration (Planning, Execution, Review)|Benefits and Challenges of Iterative Approaches|Common Iterative Methodologies (Agile, Scrum, Kanban)|Incorporating Feedback Loops for Continuous Improvement|Risk Management in Iterative Cycles|Scaling Iterative Processes in Large Organizations" +Execution,Understanding Project Plans and Objectives|Task Breakdown and Resource Allocation|Monitoring Progress and Performance Metrics|Risk Identification and Mitigation During Execution|Effective Communication and Stakeholder Management|Problem-Solving and Decision-Making in Real-Time|Quality Assurance and Control During Execution|Post-Execution Review and Lessons Learned +Blue Ocean Strategy,Introduction to Red Ocean vs. Blue Ocean Thinking|The Value Innovation Framework (Eliminate-Reduce-Raise-Create Grid)|Six Paths Framework for Reconstructing Market Boundaries|Buyer Utility Map for Uncovering New Value|Strategy Canvas for Visualizing Competitive Landscape|Overcoming Organizational Hurdles to Blue Ocean Creation|Case Studies of Successful Blue Ocean Strategies +TRIZ (Theory of Inventive Problem Solving),"Introduction to TRIZ Principles and History|Ideal Final Result (IFR) Concept|Contradiction Matrix and 40 Inventive Principles|Separation Principles (Time, Space, Condition)|Evolutionary Patterns of Technical Systems|Substance-Field Analysis (Su-Field Analysis)|Applying TRIZ to Real-World Problem Solving" +Problem Framing,"Importance of Effective Problem Framing|Distinguishing Core Problems from Symptoms|Techniques for Problem Definition (e.g., 5 Whys, Ishikawa)|Stakeholder Analysis and Perspective Gathering|Defining Scope and Constraints of the Problem|Crafting Clear and Actionable Problem Statements|Reframing Techniques for New Insights" +Product Identification,"Understanding Market Needs and Gaps|Brainstorming and Ideation Techniques|Concept Generation and Screening|Feasibility Analysis (Technical, Market, Financial)|Defining Product Vision and Scope|Developing a Minimum Viable Product (MVP) Concept|Product Differentiation and Competitive Advantage|Intellectual Property Considerations for New Products" +Market Analysis,"Introduction to Market Analysis Objectives|Market Size and Growth Rate Estimation|SWOT Analysis (Strengths, Weaknesses, Opportunities, Threats)|PESTEL Analysis (Political, Economic, Social, Technological, Environmental, Legal)|Porter's Five Forces for Industry Analysis|Market Segmentation and Targeting Strategies|Demand Forecasting Techniques|Competitive Landscape Mapping" +User Research,"Introduction to User Research Methodologies|Qualitative vs. Quantitative Research Approaches|Planning and Designing User Research Studies|Recruiting Participants for Research|Data Collection Techniques (Interviews, Surveys, Observations)|Analyzing and Synthesizing Research Data|Creating User Personas and Journey Maps|Communicating Research Findings and Recommendations|Ethical Considerations in User Research" +Identifying Market Needs,"Understanding Market Needs vs. Wants|Techniques for Discovering Unmet Needs (e.g., Observation, Empathy Mapping)|Analyzing Customer Pain Points and Frustrations|Competitive Analysis for Gaps and Opportunities|Trend Analysis and Future Forecasting|Feedback Collection Mechanisms (Surveys, Reviews, Support Tickets)|Validating Identified Needs with Potential Users|Prioritizing Market Needs for Product Development" +Competitive Analysis,"Defining Competitors (Direct, Indirect, Substitute)|Identifying Key Competitive Factors|Data Collection Methods for Competitive Intelligence|SWOT Analysis of Competitors|Benchmarking Competitor Products and Services|Analyzing Competitor Strategies (Marketing, Pricing, Distribution)|Identifying Competitive Advantages and Disadvantages|Developing a Competitive Response Strategy" +Emerging Market Trends,"Understanding the Concept of Market Trends|Sources for Identifying Emerging Trends (Reports, Research, News)|Categorization of Trends (Technological, Social, Economic)|Tools for Trend Analysis and Forecasting|Impact Assessment of Emerging Trends on Business|Scenario Planning Based on Trend Trajectories|Adapting Strategies to Leverage or Mitigate Trends" +User Personas,"Introduction to User Personas and Their Purpose|Components of a Well-Crafted Persona|Data Sources for Persona Creation (User Research, Analytics)|Techniques for Synthesizing Data into Personas|Creating Empathy Maps as a Precursor to Personas|Using Personas in Design and Development Decisions|Maintaining and Updating Personas|Avoiding Common Persona Pitfalls" +User Interviews,"Introduction to Qualitative User Interviews|Planning and Structuring Interview Questions|Recruiting and Screening Interview Participants|Conducting Effective Interviews (Active Listening, Probing)|Avoiding Bias in Interview Questions and Responses|Note-Taking and Recording Best Practices|Analyzing and Synthesizing Interview Data|Ethical Considerations in User Interviews" +Surveys and Questionnaires,"Introduction to Quantitative Research with Surveys|Designing Effective Survey Questions (Types, Wording, Scales)|Choosing Appropriate Survey Platforms and Distribution Channels|Sampling Methods and Participant Recruitment|Maximizing Response Rates and Data Quality|Analyzing Survey Data (Descriptive and Inferential Statistics)|Interpreting and Presenting Survey Results|Avoiding Common Survey Biases" +Ethnographic Research,"Introduction to Ethnographic Research Principles|Observation Techniques (Direct, Participant, Passive)|Contextual Inquiry and Field Studies|Data Collection Methods (Field Notes, Photos, Videos, Artifacts)|Building Rapport and Ethical Considerations in the Field|Analyzing and Interpreting Qualitative Ethnographic Data|Synthesizing Insights from Observations|Communicating Ethnographic Findings" +USP (Unique Selling Point),Definition and Importance of a USP|Identifying Core Product/Service Benefits|Analyzing Competitor Offerings for Differentiation|Brainstorming Potential USPs|Testing and Validating USP Claims|Crafting a Clear and Compelling USP Statement|Integrating USP into Marketing and Branding|Sustaining and Evolving Your USP +Market Segmentation,"Definition and Importance of Market Segmentation|Bases for Segmentation (Demographic, Geographic, Psychographic, Behavioral)|Targeting Strategies (Undifferentiated, Differentiated, Concentrated)|Developing Segment Profiles|Evaluating Segment Attractiveness|Positioning within Target Segments|Implementing Segmentation Strategies|Measuring the Effectiveness of Segmentation" +Case Studies,"Understanding the Purpose and Value of Case Studies|Identifying Suitable Subjects for Case Studies|Structuring a Compelling Case Study Narrative|Data Collection for Case Studies (Interviews, Data Analysis)|Crafting Problem Statements and Solutions|Quantifying Results and Demonstrating Impact|Writing and Presenting Case Studies Effectively|Using Case Studies for Marketing and Sales" +Vision & Mission,Defining Organizational Vision and Mission Statements|Distinguishing Between Vision and Mission|Components of an Effective Vision Statement|Components of an Effective Mission Statement|Developing Vision and Mission Statements Collaboratively|Aligning Vision and Mission with Organizational Values|Communicating Vision and Mission to Stakeholders|Using Vision and Mission to Guide Strategy and Decision-Making +concept,subtopics +FTP / SFTP,Understanding File Transfer Protocol basics|Setting up FTP servers|Configuring SFTP for secure transfers|FTP vs SFTP security differences|Active vs Passive FTP modes|FTP client configuration and usage|Troubleshooting FTP connection issues|FTP directory permissions and access control +DNS,DNS hierarchy and root servers|DNS record types (A AAAA CNAME MX)|DNS resolution process and queries|Configuring DNS servers|DNS caching and TTL concepts|DNS security and DNSSEC|Troubleshooting DNS issues|DNS load balancing techniques +HTTP,HTTP request and response structure|HTTP methods (GET POST PUT DELETE)|HTTP status codes and meanings|HTTP headers and their purposes|HTTP/1.1 vs HTTP/2 vs HTTP/3 differences|HTTPS and SSL/TLS integration|HTTP caching mechanisms|RESTful API design with HTTP +SSL / TLS,SSL/TLS handshake process|Certificate authorities and PKI|SSL certificate types and validation|TLS encryption algorithms and ciphers|SSL/TLS configuration best practices|Certificate installation and management|SSL/TLS troubleshooting|Perfect Forward Secrecy concepts +SSH,SSH key generation and management|SSH client and server configuration|SSH tunneling and port forwarding|SSH authentication methods|SSH security hardening|SSH file transfer with SCP and RSYNC|SSH agent and key forwarding|Troubleshooting SSH connections +White / Grey Listing,Email whitelist and greylist concepts|Implementing SPF whitelisting|DNS-based whitelisting techniques|Application-level whitelisting|IP address whitelist management|Firewall whitelist configuration|Greylist temporary blocking mechanisms|Whitelist bypass prevention +SMTP,SMTP protocol fundamentals|SMTP server configuration|Email routing and relay setup|SMTP authentication mechanisms|SMTP security and encryption|Email deliverability optimization|SMTP troubleshooting techniques|Anti-spam SMTP configurations +DMARC,DMARC policy creation and syntax|DMARC alignment requirements|DMARC reporting and analysis|SPF and DKIM integration with DMARC|DMARC deployment strategies|DMARC forensic reports|Email authentication troubleshooting|DMARC policy enforcement levels +IMAP,IMAP protocol fundamentals|IMAP vs POP3 differences|IMAP server configuration|IMAP folder synchronization|IMAP security and encryption|IMAP client configuration|IMAP performance optimization|Troubleshooting IMAP connectivity +SPF,SPF record syntax and mechanisms|SPF policy creation and testing|DNS SPF record configuration|SPF alignment and authentication|SPF record validation tools|SPF troubleshooting techniques|SPF policy optimization|SPF integration with other email security +POP3S,POP3 protocol basics|POP3S encryption setup|POP3 vs IMAP comparison|POP3 server configuration|POP3 client settings|POP3 message handling|POP3 security considerations|Migrating from POP3 to IMAP +Domain Keys,DomainKeys signature generation|DomainKeys DNS record setup|Public and private key management|DomainKeys vs DKIM differences|Email signing and verification|DomainKeys implementation|DomainKeys troubleshooting|Legacy email authentication methods +OSI Model,Physical layer fundamentals|Data link layer protocols|Network layer addressing|Transport layer protocols|Session layer management|Presentation layer encoding|Application layer services|OSI vs TCP/IP model comparison +Networking & Protocols,TCP and UDP protocol differences|Network packet structure|Protocol stack implementation|Network troubleshooting methodologies|Protocol analysis techniques|Network security protocols|Quality of Service (QoS)|Network performance optimization +Vercel,Vercel deployment pipeline|Next.js integration with Vercel|Environment variables configuration|Custom domains and SSL|Vercel Functions (serverless)|Build and deployment optimization|Monitoring and analytics|Vercel CLI usage +Cloudflare,DNS management with Cloudflare|CDN configuration and optimization|DDoS protection setup|SSL certificate management|Web Application Firewall (WAF)|Page rules and caching|Workers and Edge Functions|Analytics and performance monitoring +Azure Functions,Serverless function development|Trigger types and bindings|Azure Functions runtime versions|Local development and testing|Deployment and CI/CD integration|Monitoring and logging|Performance optimization|Cost management strategies +AWS Lambda,Lambda function creation and deployment|Event-driven architecture patterns|Lambda layers and dependencies|Cold start optimization techniques|Lambda security and IAM roles|Monitoring with CloudWatch|Lambda cost optimization|Serverless application patterns +Netlify,Static site deployment process|Git-based deployment workflows|Build configuration and optimization|Form handling and submissions|Netlify Functions implementation|Custom headers and redirects|Domain management and SSL|Analytics and performance monitoring +Provisioning,Infrastructure provisioning concepts|Automated provisioning tools|Cloud resource provisioning|Configuration management|Provisioning templates and scripts|Resource lifecycle management|Provisioning security best practices|Monitoring provisioned resources +OSCP,Penetration testing methodologies|Manual exploitation techniques|Buffer overflow exploitation|Web application security testing|Network service enumeration|Post-exploitation techniques|Report writing and documentation|Ethical hacking principles +CREST,Penetration testing standards|CREST certification pathways|Technical security assessment|Vulnerability assessment methodologies|Social engineering testing|Physical security testing|Reporting and communication|Professional ethics and conduct +CISSP,Information security governance|Asset security management|Security architecture and engineering|Communication and network security|Identity and access management|Security assessment and testing|Security operations management|Software development security +MacOS,MacOS system architecture|File system and directory structure|Terminal and command line usage|System preferences and configuration|Security features and settings|Application installation methods|Backup and recovery procedures|Troubleshooting common issues +Installation and Configuration,System requirements assessment|Pre-installation planning|Installation media preparation|Custom installation options|Post-installation configuration|Driver and software updates|System optimization settings|Configuration backup procedures +Different Versions and Differences,Version comparison methodologies|Compatibility assessment|Migration planning strategies|Feature comparison analysis|Performance benchmarking|Security improvement analysis|Upgrade path planning|Rollback procedures +Navigating using GUI and CLI,Graphical interface navigation|Command line interface basics|Keyboard shortcuts and hotkeys|File manager usage|System administration tools|Task management interfaces|Search and filtering techniques|Accessibility features +Understand Permissions,File system permissions|User and group management|Permission inheritance models|Access control lists (ACLs)|Special permissions and attributes|Permission troubleshooting|Security implications|Cross-platform permission differences +Installing Software and Applications,Package management systems|Software repositories|Dependency resolution|Installation verification|Software updates and patches|Uninstallation procedures|Portable application management|Security considerations +Performing CRUD on Files,Create file operations|Read and view file contents|Update and modify files|Delete and remove files|File copy and move operations|Batch file operations|File attribute management|File recovery techniques +Troubleshooting,Problem identification techniques|Systematic troubleshooting approach|Log file analysis|Diagnostic tool usage|Root cause analysis|Solution implementation|Testing and verification|Documentation and knowledge sharing +Common Commands,File and directory commands|System information commands|Process management commands|Network diagnostic commands|Text processing commands|Archive and compression commands|Permission and ownership commands|Help and documentation commands +Networking Knowledge,Network topology concepts|IP addressing and subnetting|Routing protocols and tables|Switching and VLANs|Network security fundamentals|Wireless networking principles|Network performance monitoring|Troubleshooting network issues +Understand the OSI Model,Layer 1 Physical specifications|Layer 2 Data Link protocols|Layer 3 Network addressing|Layer 4 Transport protocols|Layer 5 Session management|Layer 6 Presentation formatting|Layer 7 Application services|Inter-layer communication +Common Protocols and their Uses,HTTP/HTTPS web protocols|FTP file transfer protocols|SMTP email protocols|DNS name resolution|DHCP address assignment|SNMP network management|SSH secure remote access|Telnet remote terminal access +Common Ports and their Uses,Well-known port assignments|Registered port ranges|Dynamic port allocation|Port security considerations|Port scanning techniques|Firewall port configuration|Service port identification|Port conflict resolution +SSL and TLS Basics,Cryptographic handshake process|Certificate validation|Cipher suite negotiation|Public key infrastructure|SSL/TLS versions comparison|Certificate chain verification|Perfect forward secrecy|Common vulnerabilities +Basics of NAS and SAN,Network Attached Storage architecture|Storage Area Network design|File-level vs block-level access|RAID configuration options|Network protocols for storage|Performance optimization|Backup and disaster recovery|Storage capacity planning +Basics of Subnetting,IP address classes|Subnet mask calculation|CIDR notation usage|Network and broadcast addresses|Variable Length Subnet Masking|Subnetting best practices|Route summarization|Subnet design strategies +Public vs Private IP Addresses,RFC 1918 private address ranges|Public IP address allocation|NAT and PAT concepts|IPv4 address exhaustion|IPv6 addressing schemes|IP address planning|Security implications|Dynamic vs static addressing +localhost,Loopback interface concept|Local service testing|Development environment setup|Port binding on localhost|Security implications|Cross-platform localhost behavior|Localhost vs 127.0.0.1|Local networking troubleshooting +loopback,Loopback interface configuration|Network testing with loopback|Loopback address ranges|Virtual loopback interfaces|Routing with loopback|Loopback security considerations|Troubleshooting loopback issues|Loopback vs physical interfaces +CIDR,Classless Inter-Domain Routing notation|CIDR block allocation|Route aggregation techniques|CIDR vs classful addressing|Subnet calculation with CIDR|VLSM implementation|BGP and CIDR|Network planning with CIDR +subnet mask,Binary subnet mask representation|Decimal subnet mask notation|Subnet mask calculation methods|Variable length subnet masks|Subnet mask troubleshooting|Custom subnet mask creation|Subnet mask validation|Network design considerations +default gateway,Gateway configuration setup|Routing table entries|Gateway selection process|Multiple gateway scenarios|Gateway failover mechanisms|Default route configuration|Gateway performance optimization|Troubleshooting gateway issues +VLAN,Virtual LAN concepts|VLAN tagging protocols|Inter-VLAN routing|VLAN configuration on switches|VLAN security considerations|VLAN troubleshooting|Dynamic VLAN assignment|VLAN best practices +DMZ,Demilitarized Zone architecture|DMZ security policies|Firewall DMZ configuration|DMZ service deployment|Network segmentation strategies|DMZ monitoring and logging|DMZ access control|DMZ vulnerability management +ARP,Address Resolution Protocol operation|ARP table management|ARP spoofing attacks|Gratuitous ARP usage|ARP cache optimization|ARP troubleshooting techniques|Proxy ARP configuration|ARP security considerations +VM,Virtual machine architecture|Hypervisor types and features|VM resource allocation|VM networking configuration|VM storage management|VM security considerations|VM backup and recovery|VM performance optimization +DHCP,DHCP lease process|DHCP server configuration|DHCP reservation setup|DHCP option configuration|DHCP troubleshooting|DHCP failover and redundancy|DHCP security considerations|Dynamic DNS integration +NAT,Network Address Translation concepts|Static NAT configuration|Dynamic NAT operation|PAT (Port Address Translation)|NAT traversal techniques|NAT security implications|NAT performance considerations|NAT troubleshooting +IP,IP addressing fundamentals|IPv4 vs IPv6 comparison|IP packet structure|IP routing concepts|IP fragmentation handling|IP quality of service|IP security extensions|IP troubleshooting tools +Router,Router architecture and components|Routing table management|Dynamic routing protocols|Static route configuration|Router security hardening|Router performance optimization|Router troubleshooting|Router redundancy setup +Switch,Layer 2 switching concepts|MAC address learning|Spanning Tree Protocol|Switch port configuration|VLAN implementation|Switch security features|Switch troubleshooting|Switch stacking and bonding +VPN,VPN protocols and types|Site-to-site VPN setup|Remote access VPN configuration|VPN encryption methods|VPN authentication mechanisms|VPN troubleshooting|VPN performance optimization|VPN security best practices +MAN,Metropolitan Area Network design|MAN technologies and protocols|MAN vs WAN differences|MAN service provider options|MAN security considerations|MAN performance optimization|MAN cost analysis|MAN redundancy planning +LAN,Local Area Network architecture|LAN protocols and standards|Ethernet technology|LAN security implementation|LAN performance monitoring|LAN troubleshooting|Wireless LAN integration|LAN expansion strategies +WAN,Wide Area Network technologies|WAN connectivity options|WAN optimization techniques|WAN security implementations|WAN cost management|WAN redundancy design|WAN performance monitoring|WAN troubleshooting +WLAN,Wireless LAN standards|Access point deployment|Wireless security protocols|WLAN performance optimization|Wireless site surveys|WLAN troubleshooting|Guest network setup|Enterprise WLAN management +NTP,Network Time Protocol operation|NTP server hierarchy|Time synchronization accuracy|NTP security considerations|NTP troubleshooting|Chrony vs NTP comparison|GPS time source integration|NTP monitoring and logging +IPAM,IP Address Management systems|IP address allocation strategies|DHCP and DNS integration|IPAM database design|Automated IP discovery|IP address lifecycle management|IPAM reporting and analytics|IPAM security considerations +Star,Star topology advantages|Central hub requirements|Star network scalability|Fault tolerance in star networks|Cable management in star topology|Star topology troubleshooting|Cost analysis of star networks|Star topology security considerations +Ring,Ring topology operation|Token passing mechanisms|Ring network fault tolerance|Fiber optic ring networks|Ring topology troubleshooting|Ring network performance|SONET/SDH ring networks|Ring topology redundancy +Mesh,Mesh topology design|Full mesh vs partial mesh|Wireless mesh networks|Mesh routing protocols|Mesh network scalability|Self-healing mesh capabilities|Mesh topology cost analysis|Mesh network security +Bus,Bus topology fundamentals|Collision detection mechanisms|Bus network limitations|Coaxial cable bus networks|Bus topology troubleshooting|Legacy bus network migration|Bus network performance issues|Bus topology security vulnerabilities +RDP,Remote Desktop Protocol setup|RDP security hardening|RDP performance optimization|RDP licensing requirements|RDP troubleshooting|Alternative remote access solutions|RDP network requirements|RDP session management +FTP,File Transfer Protocol basics|FTP server configuration|FTP client usage|Active vs passive FTP modes|FTP security considerations|FTPS vs SFTP comparison|FTP automation scripting|FTP troubleshooting techniques +SFTP,SSH File Transfer Protocol setup|SFTP vs FTP security differences|SFTP client configuration|SFTP server hardening|SFTP key management|SFTP automation and scripting|SFTP performance optimization|SFTP troubleshooting +VMWare,VMware vSphere architecture|Virtual machine management|ESXi hypervisor configuration|vCenter Server administration|VMware networking concepts|Storage management with VMware|VMware security best practices|VMware performance optimization +VirtualBox,VirtualBox installation and setup|Virtual machine creation|VirtualBox networking modes|Shared folders and clipboard|VirtualBox guest additions|Snapshot management|VirtualBox CLI usage|VirtualBox troubleshooting +esxi,ESXi installation and configuration|ESXi networking setup|Virtual machine management|ESXi storage configuration|ESXi security hardening|ESXi monitoring and logging|ESXi backup strategies|ESXi troubleshooting +proxmox,Proxmox VE installation|Container and VM management|Proxmox clustering setup|Storage configuration|Network configuration|Backup and restore procedures|Proxmox web interface usage|High availability configuration +Hypervisor,Type 1 vs Type 2 hypervisors|Hypervisor architecture|Resource allocation and scheduling|Hardware virtualization support|Hypervisor security considerations|Performance optimization|Hypervisor migration|Virtualization troubleshooting +GuestOS,Guest operating system installation|Guest OS optimization|Integration services setup|Guest OS security hardening|Resource allocation for guests|Guest OS backup strategies|Cross-platform guest support|Guest OS troubleshooting +HostOS,Host operating system requirements|Host OS optimization for virtualization|Security hardening of host systems|Resource management|Host OS monitoring|Backup and disaster recovery|Host OS maintenance|Performance tuning +nslookup,DNS lookup command usage|Forward and reverse DNS queries|Query type specification|Nslookup troubleshooting|Interactive vs non-interactive mode|DNS server specification|Record type queries|Debugging DNS issues +iptables,Iptables rule syntax|Chain management (INPUT OUTPUT FORWARD)|Target actions (ACCEPT REJECT DROP)|NAT and port forwarding|Packet matching criteria|Iptables script automation|Firewall policy design|Iptables troubleshooting +Packet Sniffers,Network traffic capture techniques|Packet analysis methodologies|Protocol decoding|Traffic filtering and search|Performance impact considerations|Legal and ethical considerations|Popular packet sniffing tools|Network troubleshooting with sniffers +ipconfig,IP configuration display|Network adapter information|DNS cache management|DHCP lease renewal|Network troubleshooting with ipconfig|Command line options|Cross-platform alternatives|Network configuration validation +netstat,Network connection display|Listening port identification|Process and PID association|Network statistics viewing|TCP connection states|UDP connection monitoring|Routing table display|Network troubleshooting techniques +Port Scanners,Port scanning techniques|Stealth scanning methods|Service enumeration|Port scan interpretation|Nmap usage and options|Scan timing and performance|Legal and ethical considerations|Defense against port scans +ping,ICMP ping operation|Network connectivity testing|Ping response analysis|Continuous ping monitoring|Ping flood testing|IPv6 ping usage|Ping troubleshooting|Network latency measurement +dig,DNS lookup with dig command|Query type specification|Authoritative vs recursive queries|DNS server targeting|Output format options|Reverse DNS lookups|DNS troubleshooting with dig|Batch DNS queries +Protocol Analyzers,Network protocol analysis|Deep packet inspection|Traffic pattern recognition|Performance bottleneck identification|Security threat detection|Protocol compliance testing|Network forensics|Troubleshooting network issues +nmap,Network discovery techniques|Port scanning methodologies|Service version detection|Operating system fingerprinting|Vulnerability scanning|Nmap scripting engine|Stealth scanning techniques|Network security assessment +route,Routing table management|Static route configuration|Route addition and deletion|Route metrics and priorities|Default route setup|Route troubleshooting|Dynamic routing integration|Multi-homed routing +tcpdump,Packet capture with tcpdump|Capture filter expressions|Output format options|Real-time packet analysis|Capture file management|Network troubleshooting techniques|Performance considerations|Security monitoring +tracert,Route tracing methodology|Hop-by-hop analysis|Network path identification|Latency measurement|MTU discovery|IPv6 traceroute|Troubleshooting routing issues|Network topology mappingUnderstand Basics of Forensics,Digital evidence collection procedures|Chain of custody documentation|File system analysis techniques|Memory dump acquisition and analysis|Network forensics methodologies|Mobile device forensics|Timeline analysis and reconstruction|Forensic reporting and testimony +Basics and Concepts of Threat Hunting,Hypothesis-driven hunting approaches|Threat intelligence integration|Behavioral analysis techniques|IOC and IOA identification|SIEM and log analysis for hunting|Network traffic analysis|Endpoint detection and response|Threat hunting team organization +Basics of Vulnerability Management,Vulnerability assessment methodologies|Vulnerability scanning tools and techniques|Risk scoring and prioritization|Patch management workflows|Vulnerability lifecycle management|False positive identification|Remediation tracking and validation|Compliance and reporting requirements +Basics of Reverse Engineering,Static analysis techniques|Dynamic analysis methods|Disassembly and decompilation|Binary analysis tools|Malware reverse engineering|Protocol reverse engineering|Code obfuscation analysis|Vulnerability research techniques +Penetration Testing Rules of Engagement,Scope definition and boundaries|Authorization and legal frameworks|Testing methodologies and standards|Communication protocols|Escalation procedures|Documentation requirements|Post-testing cleanup procedures|Ethical considerations and limitations +Perimiter vs DMZ vs Segmentation,Network perimeter security concepts|DMZ architecture and implementation|Network segmentation strategies|Micro-segmentation techniques|Zero trust network principles|VLAN and subnet isolation|Firewall placement and configuration|Security zone design +Core Concepts of Zero Trust,Zero trust architecture principles|Identity verification requirements|Continuous authentication methods|Least privilege access controls|Network segmentation strategies|Device trust and compliance|Data protection and encryption|Zero trust implementation planning +Roles of Compliance and Auditors,Regulatory compliance frameworks|Audit planning and execution|Control testing methodologies|Risk assessment and management|Compliance monitoring and reporting|Remediation tracking|Auditor independence requirements|Documentation and evidence management +Understand the Definition of Risk,Risk identification methodologies|Qualitative vs quantitative risk analysis|Risk assessment frameworks|Risk tolerance and appetite|Risk mitigation strategies|Risk monitoring and review|Business impact analysis|Risk communication techniques +Understand Backups and Resiliency,Backup strategy planning|Recovery point and time objectives|Backup types and methodologies|Disaster recovery planning|Business continuity management|High availability design|Failover and failback procedures|Testing and validation processes +Cyber Kill Chain,Reconnaissance phase analysis|Weaponization stage identification|Delivery mechanism detection|Exploitation techniques|Installation and persistence|Command and control detection|Actions on objectives|Kill chain disruption strategies +MFA & 2FA,Authentication factor categories|SMS and voice-based authentication|App-based authenticator setup|Hardware token implementation|Biometric authentication methods|Risk-based authentication|MFA bypass techniques|User experience considerations +Operating System Hardening,Security configuration baselines|Service and feature reduction|User account management|File system permissions|Network service configuration|Logging and monitoring setup|Update and patch management|Security tool integration +Understand Concept of Isolation,Process isolation mechanisms|Network isolation techniques|Container and VM isolation|Application sandboxing|Data isolation strategies|Physical isolation requirements|Cloud isolation models|Isolation testing and validation +Basics of IDS and IPS,Intrusion detection methodologies|Signature-based vs anomaly detection|Network vs host-based systems|IPS deployment strategies|Rule and signature management|False positive reduction|Performance optimization|Integration with SIEM systems +Honeypots,Honeypot deployment strategies|Low vs high interaction systems|Network honeypot configuration|Application honeypot setup|Data collection and analysis|Legal and ethical considerations|Honeypot maintenance|Threat intelligence generation +Authentication vs Authorization,Authentication mechanisms|Authorization models and frameworks|Role-based access control|Attribute-based access control|Single sign-on implementation|Federation and trust relationships|Access control testing|Privilege management +Blue / Red / Purple Teams,Blue team defensive operations|Red team offensive techniques|Purple team collaboration|Exercise planning and execution|Threat simulation methodologies|Skills development and training|Tool and technique sharing|Performance measurement +False Negative / False Positive,Detection accuracy metrics|Tuning and optimization techniques|Cost-benefit analysis|Alert fatigue management|Baseline establishment|Statistical analysis methods|Quality assurance processes|Continuous improvement strategies +True Negative / True Positive,Classification accuracy assessment|Confusion matrix analysis|Precision and recall metrics|ROC curve interpretation|Model validation techniques|Performance benchmarking|Alert quality measurement|Decision threshold optimization +"Basics of Threat Intel, OSINT",Threat intelligence lifecycle|OSINT collection methodologies|Source evaluation and validation|Intelligence analysis techniques|Indicator extraction and sharing|Threat actor profiling|Attribution analysis|Intelligence dissemination +Understand Handshakes,TCP three-way handshake|TLS/SSL handshake process|Authentication handshakes|Key exchange mechanisms|Handshake optimization|Troubleshooting connection issues|Security considerations|Performance impact analysis +Understand CIA Triad,Confidentiality protection methods|Integrity assurance techniques|Availability management strategies|Risk assessment frameworks|Security control implementation|Compliance and governance|Incident response procedures|Security awareness training +Privilege Escalation,Horizontal privilege escalation|Vertical privilege escalation|Windows privilege escalation|Linux privilege escalation|Web application privilege escalation|Database privilege escalation|Prevention and detection techniques|Post-exploitation techniques +Web Based Attacks and OWASP10,Injection attack techniques|Broken authentication exploitation|Sensitive data exposure|XML external entity attacks|Broken access control|Security misconfiguration|Cross-site scripting (XSS)|Insecure deserialization +Learn how Malware works and Types,Virus replication mechanisms|Worm propagation methods|Trojan horse techniques|Ransomware encryption|Spyware data collection|Adware distribution|Rootkit hiding techniques|Advanced persistent threats +curl,HTTP request methods with curl|Authentication mechanisms|Cookie and session handling|File upload and download|SSL certificate verification|Proxy configuration|Scripting and automation|Troubleshooting connection issues +hping,TCP packet crafting|UDP packet generation|ICMP packet construction|Network reconnaissance|Firewall testing|DoS attack simulation|Traceroute functionality|Performance testing +cat,File content display|Multiple file concatenation|Standard input processing|Binary file handling|Pipe and redirection usage|Text processing workflows|Script integration|Performance considerations +dd,Block-level data copying|Disk imaging and cloning|Data conversion options|Progress monitoring|Error handling|Performance optimization|Forensic applications|Backup and recovery +head,File beginning display|Line count specification|Byte count options|Multiple file processing|Pipe integration|Log file analysis|Script automation|Performance considerations +grep,Pattern matching fundamentals|Regular expression usage|File search operations|Recursive directory searching|Case sensitivity options|Output formatting|Performance optimization|Advanced pattern techniques +wireshark,Packet capture setup|Protocol analysis|Display filter creation|Network troubleshooting|Security analysis|Performance analysis|Custom dissector development|Capture file management +winhex,Hex editing fundamentals|Binary file analysis|Data recovery techniques|Disk sector editing|Template and script usage|Forensic applications|Data comparison|File signature analysis +memdump,Memory acquisition techniques|Live memory analysis|Process memory extraction|Kernel memory dumping|Memory image formats|Analysis tool integration|Volatile data preservation|Forensic best practices +FTK Imager,Disk imaging procedures|Evidence acquisition|Hash verification|Preview capabilities|Registry analysis|File system examination|Report generation|Chain of custody documentation +autopsy,Digital forensics workflow|Case management|File system analysis|Timeline creation|Keyword searching|Hash database integration|Report generation|Plugin development +tail,File end monitoring|Real-time log viewing|Line count specification|Multiple file tracking|Rotation handling|Pipe integration|Performance optimization|System monitoring +Salting,Password salt generation|Hash salt implementation|Rainbow table prevention|Salt storage strategies|Cryptographic best practices|Salt uniqueness requirements|Performance considerations|Security analysis +Hashing,Hash function properties|Cryptographic hash algorithms|Message digest creation|Hash collision analysis|Digital signature integration|Password hashing|File integrity verification|Performance optimization +Key Exchange,Diffie-Hellman protocol|RSA key exchange|Elliptic curve methods|Perfect forward secrecy|Key agreement protocols|Security considerations|Implementation best practices|Performance optimization +PKI,Certificate authority hierarchy|Digital certificate lifecycle|Certificate validation|Revocation mechanisms|Trust store management|Key escrow considerations|Cross-certification|PKI deployment strategies +Private vs Public Keys,Asymmetric cryptography concepts|Key pair generation|Digital signature creation|Encryption and decryption|Key management practices|Security considerations|Performance implications|Use case selection +Obfuscation,Code obfuscation techniques|Anti-reverse engineering methods|Binary packing|Control flow obfuscation|Data obfuscation strategies|Performance impact analysis|Deobfuscation techniques|Security effectiveness assessment +ATT&CK,MITRE ATT&CK framework|Tactic and technique mapping|Threat actor profiling|Detection rule development|Red team exercise planning|Security control assessment|Intelligence analysis|Framework implementation +Kill Chain,Cyber kill chain methodology|Attack phase identification|Defensive strategies|Intelligence requirements|Threat hunting applications|Incident response integration|Risk assessment|Mitigation planning +Diamond Model,Adversary capability analysis|Infrastructure identification|Victim characterization|Event correlation|Threat intelligence development|Attribution analysis|Defensive planning|Intelligence sharing +ISO,ISO 27001 implementation|Information security management|Risk assessment procedures|Control framework selection|Audit and compliance|Continuous improvement|Documentation requirements|Certification process +RMF,Risk Management Framework steps|Categorization procedures|Control selection process|Implementation guidance|Assessment methodologies|Authorization decisions|Monitoring strategies|Framework integration +CIS,CIS Controls implementation|Cybersecurity framework|Control prioritization|Maturity assessment|Implementation guidance|Measurement and metrics|Compliance mapping|Continuous improvement +CSF,NIST Cybersecurity Framework|Identify function implementation|Protect function strategies|Detect function capabilities|Respond function procedures|Recover function planning|Framework adoption|Maturity assessment +SIEM,Security event correlation|Log collection and normalization|Incident detection rules|Dashboard and reporting|Threat intelligence integration|Use case development|Tuning and optimization|Compliance reporting +SOAR,Security orchestration platforms|Automated response workflows|Playbook development|Integration capabilities|Incident response automation|Threat intelligence automation|Case management|Performance metrics +ParrotOS,Penetration testing toolkit|Security assessment tools|Digital forensics capabilities|Privacy and anonymity tools|System customization|Tool integration|Workflow optimization|Update management +Kali Linux,Penetration testing distribution|Information gathering tools|Vulnerability assessment|Web application testing|Wireless security testing|Digital forensics tools|Exploitation frameworks|Post-exploitation tools +LOLBAS,Living off the land techniques|Legitimate tool abuse|Windows binary exploitation|PowerShell living off land|Command line evasion|Detection evasion techniques|Incident response challenges|Defensive strategies +Event Logs,Windows event log analysis|Security event correlation|Log parsing techniques|Threat hunting with logs|Incident investigation|Log retention policies|SIEM integration|Forensic analysis +syslogs,Syslog protocol standards|Log forwarding configuration|Centralized logging setup|Log parsing and analysis|Security monitoring|Troubleshooting techniques|Performance optimization|Compliance requirements +netflow,Network flow monitoring|Flow data collection|Traffic analysis techniques|Security monitoring|Capacity planning|Performance optimization|Tool integration|Anomaly detection +Packet Captures,Network traffic capture|Protocol analysis|Security investigation|Performance troubleshooting|Capture optimization|Storage management|Analysis techniques|Legal considerations +Firewall Logs,Log format understanding|Security event analysis|Traffic pattern identification|Incident investigation|Compliance reporting|Performance monitoring|Alert correlation|Automation techniques +MAC-based,Media Access Control filtering|MAC address management|Wireless security implementation|Network access control|Spoofing prevention|Device identification|Authentication integration|Limitations and bypasses +NAC-based,Network Access Control deployment|Device posture assessment|Quarantine procedures|Guest network management|Compliance enforcement|Integration strategies|Troubleshooting techniques|Performance considerations +Port Blocking,Firewall port configuration|Service restriction policies|Application control|Security hardening|Network segmentation|Performance impact|Troubleshooting connectivity|Exception management +Group Policy,Active Directory policy management|Security configuration|User environment control|Software deployment|Registry modification|Troubleshooting techniques|Best practices|Performance optimization +ACLs,Access Control List configuration|Permission management|File system security|Network access control|Troubleshooting access issues|Inheritance concepts|Performance considerations|Security best practices +Sinkholes,DNS sinkhole implementation|Malware communication blocking|Threat intelligence integration|Network traffic redirection|Monitoring and analysis|Performance considerations|False positive management|Legal considerations +Patching,Patch management lifecycle|Vulnerability assessment|Testing procedures|Deployment strategies|Rollback procedures|Compliance tracking|Automation techniques|Risk assessment +Jump Server,Privileged access management|Secure remote access|Session recording|Access control implementation|Monitoring and auditing|High availability setup|Security hardening|Troubleshooting connectivity +Endpoint Security,Endpoint protection platforms|Malware detection|Behavioral analysis|Device compliance|Remote management|Incident response|Performance optimization|Integration strategies +FTP vs SFTP,Protocol security comparison|Authentication mechanisms|Encryption implementation|Port usage differences|Firewall configuration|Performance considerations|Migration strategies|Use case selection +SSL vs TLS,Protocol version differences|Security improvements|Cipher suite evolution|Vulnerability mitigation|Configuration best practices|Performance optimization|Compatibility considerations|Migration planning +IPSEC,IPSec protocol suite|VPN implementation|Encryption algorithms|Authentication headers|Security associations|Tunnel vs transport mode|Configuration procedures|Troubleshooting techniques +DNSSEC,DNS Security Extensions|Digital signature validation|Trust anchor management|Zone signing procedures|Validation process|Implementation challenges|Performance impact|Troubleshooting techniques +LDAPS,LDAP over SSL implementation|Certificate management|Secure authentication|Directory service security|Configuration procedures|Performance optimization|Troubleshooting techniques|Migration strategies +SRTP,Secure Real-time Transport Protocol|Voice over IP security|Key management|Encryption algorithms|Implementation procedures|Performance considerations|Interoperability issues|Troubleshooting techniques +S/MIME,Secure email messaging|Digital signatures|Email encryption|Certificate management|Client configuration|Interoperability considerations|Key management|Troubleshooting issuesVirusTotal,File and URL scanning procedures|Malware analysis integration|API usage and automation|Community intelligence leveraging|False positive identification|Threat hunting applications|Report interpretation|Enterprise deployment +Joe Sandbox,Dynamic malware analysis|Sandbox environment setup|Behavioral analysis reports|API integration|Custom analysis configurations|Threat intelligence extraction|Report customization|Performance optimization +any.run,Interactive malware analysis|Real-time behavior monitoring|Network traffic analysis|Registry and file monitoring|Screenshot and video capture|API automation|Threat intelligence integration|Analysis report generation +urlvoid,URL reputation checking|Malicious website detection|API integration|Threat intelligence feeds|False positive handling|Automated scanning workflows|Report analysis|Security tool integration +urlscan,Website analysis and screenshots|Malicious content detection|DOM analysis|Network request monitoring|API automation|Threat hunting applications|Report interpretation|Integration strategies +WHOIS,Domain registration lookup|Contact information retrieval|Historical WHOIS data|Privacy protection analysis|Threat intelligence applications|API integration|Automation techniques|Investigation procedures +Phishing,Email-based social engineering|Phishing campaign identification|Email analysis techniques|URL analysis procedures|User awareness training|Technical countermeasures|Incident response procedures|Threat intelligence integration +Whishing,Voice-based social engineering|Phone call attack vectors|Caller ID spoofing|Social manipulation techniques|Detection strategies|Prevention measures|Incident response|User education +Whaling,Executive targeting techniques|High-value target identification|Advanced social engineering|Business email compromise|Detection strategies|Executive protection|Incident response|Awareness training +Smishing,SMS-based phishing attacks|Mobile threat vectors|Text message analysis|Mobile security measures|User awareness training|Technical countermeasures|Incident response|Threat intelligence +Spam vs Spim,Email spam identification|Instant messaging spam|Filtering mechanisms|Anti-spam technologies|User education|Legal considerations|Threat intelligence|Prevention strategies +Shoulder Surfing,Physical observation techniques|Visual eavesdropping methods|Prevention strategies|Environmental awareness|Screen privacy protection|Behavioral countermeasures|Detection techniques|Security awareness +Dumpster Diving,Physical information gathering|Document disposal security|Privacy protection measures|Information classification|Secure disposal procedures|Detection strategies|Physical security controls|Awareness training +Tailgating,Physical access control bypassing|Social engineering techniques|Access control weaknesses|Prevention strategies|Security awareness training|Physical security measures|Detection systems|Incident response +Social Engineering,Human psychology exploitation|Manipulation techniques|Trust building strategies|Information elicitation|Prevention and awareness|Technical countermeasures|Incident response|Training programs +Reconnaissance,Information gathering techniques|Open source intelligence|Network enumeration|Social media intelligence|Technical reconnaissance|Passive vs active methods|Threat modeling|Defensive strategies +Impersonation,Identity deception techniques|Authority figure exploitation|Digital impersonation|Voice and communication mimicking|Detection strategies|Prevention measures|Incident response|Legal considerations +Watering Hole Attack,Targeted website compromise|Victim profiling techniques|Exploit kit deployment|Detection strategies|Prevention measures|Incident response|Threat intelligence|Defensive tactics +Drive by Attack,Malicious website exploitation|Browser vulnerability exploitation|Exploit kit analysis|Detection techniques|Prevention strategies|Web security measures|Incident response|Threat hunting +Typo Squatting,Domain name exploitation|Brand impersonation|User misdirection techniques|Detection strategies|Prevention measures|Legal remedies|Monitoring techniques|Brand protection +Brute Force vs Password Spray,Password attack methodologies|Attack vector differences|Detection strategies|Prevention techniques|Account lockout policies|Authentication strengthening|Monitoring approaches|Incident response +DoS vs DDoS,Denial of service concepts|Distributed attack coordination|Attack vector analysis|Mitigation strategies|Network protection|Incident response|Recovery procedures|Prevention techniques +MITM,Man-in-the-middle attack vectors|Interception techniques|Certificate manipulation|Detection strategies|Prevention measures|Encryption importance|Network security|Incident response +Spoofing,Identity falsification techniques|IP address spoofing|Email spoofing methods|DNS spoofing attacks|Detection strategies|Prevention measures|Authentication mechanisms|Incident response +Evil Twin,Rogue wireless access point|Network impersonation|Credential harvesting|Detection techniques|Prevention strategies|Wireless security measures|User education|Incident response +DNS Poisoning,DNS cache manipulation|Malicious redirection|Attack vectors|Detection techniques|Prevention strategies|DNS security measures|Incident response|Recovery procedures +Deauth Attack,Wireless deauthentication|802.11 protocol exploitation|Attack execution|Detection methods|Prevention strategies|Wireless security hardening|Monitoring techniques|Incident response +VLAN Hopping,VLAN security bypass|Switch exploitation|Attack methodologies|Detection techniques|Prevention strategies|Network segmentation|Security hardening|Incident response +Rogue Access Point,Unauthorized wireless devices|Network infiltration|Detection techniques|Prevention strategies|Wireless security policies|Monitoring systems|Incident response|Physical security +Buffer Overflow,Memory corruption exploitation|Stack-based overflows|Heap-based overflows|Exploit development|Detection techniques|Prevention strategies|Code security|Vulnerability assessment +Memory Leak,Resource management failures|Memory allocation issues|Performance impact|Detection techniques|Prevention strategies|Code review practices|Testing methodologies|Debugging techniques +XSS,Cross-site scripting vectors|Reflected XSS attacks|Stored XSS vulnerabilities|DOM-based XSS|Detection techniques|Prevention strategies|Input validation|Output encoding +SQL Injection,Database query manipulation|Attack vector analysis|Blind injection techniques|Union-based attacks|Detection methods|Prevention strategies|Secure coding practices|Database security +CSRF,Cross-site request forgery|Attack vector analysis|Token-based protection|Same-origin policy|Detection techniques|Prevention strategies|Secure development|Testing methodologies +Replay Attack,Session replay exploitation|Token reuse attacks|Detection techniques|Prevention strategies|Cryptographic countermeasures|Session management|Security protocols|Incident response +Pass the Hash,Credential reuse attacks|Windows authentication exploitation|Lateral movement techniques|Detection strategies|Prevention measures|Credential protection|Monitoring techniques|Incident response +Directory Traversal,Path manipulation attacks|File system access bypass|Attack vector analysis|Detection techniques|Prevention strategies|Input validation|Access controls|Security testing +Stakeholders,Stakeholder identification|Interest analysis|Communication strategies|Engagement planning|Conflict resolution|Requirements gathering|Project success factors|Relationship management +HR,Human resource management|Recruitment and selection|Performance management|Employee relations|Compensation and benefits|Training and development|Legal compliance|Organizational development +Legal,Legal compliance requirements|Regulatory frameworks|Contract management|Intellectual property|Privacy laws|Risk management|Litigation support|Policy development +Compliance,Regulatory requirement management|Compliance framework implementation|Audit preparation|Risk assessment|Policy development|Training programs|Monitoring and reporting|Remediation procedures +Management,Leadership principles|Strategic planning|Team management|Performance management|Communication skills|Decision making|Resource allocation|Change management +Cloud Skills and Knowledge,Cloud service models|Deployment models|Cloud architecture|Security considerations|Cost optimization|Migration strategies|Governance frameworks|Service management +Understand the Concept of Security in the Cloud,Shared responsibility model|Cloud security frameworks|Identity and access management|Data protection|Network security|Compliance requirements|Incident response|Security monitoring +Understand the basics and general flow of deploying in the cloud,Cloud deployment models|Infrastructure provisioning|Application deployment|CI/CD pipelines|Configuration management|Monitoring setup|Scaling strategies|Cost optimization +Understand the differences between cloud and on-premises,Infrastructure ownership|Cost models|Scalability differences|Security responsibilities|Compliance considerations|Performance characteristics|Management approaches|Migration strategies +Understand the concept of Infrastructure as Code,IaC principles and benefits|Declarative vs imperative approaches|Version control integration|Infrastructure automation|Testing strategies|Deployment pipelines|Configuration management|Best practices +Understand the Concept of Serverless,Function as a Service concepts|Event-driven architecture|Serverless frameworks|Cold start optimization|Cost models|Scaling characteristics|Monitoring strategies|Security considerations +SaaS,Software as a Service models|Multi-tenancy architecture|Subscription management|Integration strategies|Data security|Compliance considerations|Vendor evaluation|Migration planning +PaaS,Platform as a Service offerings|Development environment|Application deployment|Service integration|Scaling mechanisms|Vendor lock-in considerations|Cost optimization|Security responsibilities +IaaS,Infrastructure as a Service models|Virtual machine management|Storage services|Network configuration|Security responsibilities|Cost management|Resource optimization|Service level agreements +Private,Private cloud architecture|On-premises deployment|Security advantages|Cost considerations|Scalability limitations|Management overhead|Compliance benefits|Hybrid integration +Public,Public cloud services|Multi-tenant environments|Cost advantages|Scalability benefits|Security considerations|Vendor dependencies|Service availability|Compliance challenges +Hybrid,Hybrid cloud architecture|Workload distribution|Data synchronization|Network connectivity|Security integration|Management complexity|Cost optimization|Migration strategies +GCP,Google Cloud Platform services|Compute engine management|Cloud storage solutions|BigQuery analytics|Kubernetes engine|Identity and access management|Networking services|Cost optimization +Dropbox,File synchronization services|Collaboration features|Security controls|API integration|Business administration|Compliance features|Mobile access|Storage management +Box,Enterprise file sharing|Collaboration workflows|Security and compliance|API development|Administrative controls|Integration capabilities|Mobile access|Governance features +OneDrive,Microsoft file storage|Office 365 integration|Synchronization features|Sharing and collaboration|Security controls|Administrative management|Mobile access|Business features +Google Drive,File storage and sharing|Google Workspace integration|Collaboration features|API development|Security controls|Administrative management|Mobile access|Backup solutions +GTFOBINS,Unix binary exploitation|Living off the land techniques|Privilege escalation methods|File read/write capabilities|Command execution|Bypass techniques|Detection strategies|Defensive measures +WADCOMS,Windows command reference|Attack technique documentation|Post-exploitation commands|Privilege escalation|Persistence mechanisms|Defense evasion|Collection techniques|Exfiltration methods +ORACLE,Oracle database architecture|SQL query optimization|PL/SQL programming|Database administration|Performance tuning|Security configuration|Backup and recovery|High availability +TRANSACTIONS,Database transaction concepts|ACID properties|Transaction isolation levels|Concurrency control|Deadlock handling|Performance optimization|Distributed transactions|Error handling +DATA-DRIVEN DECISION MAKING,Data collection strategies|Analysis methodologies|Statistical interpretation|Visualization techniques|Business intelligence|Performance metrics|Decision frameworks|Continuous improvement +AGILE,Agile methodology principles|Scrum framework implementation|Sprint planning and execution|User story development|Daily standups|Retrospectives|Continuous improvement|Team collaboration +CONFLUENCE,Wiki platform administration|Content creation and organization|Collaboration workflows|Template development|Permission management|Integration capabilities|Reporting features|Maintenance procedures +DOCKER,Container fundamentals|Image creation and management|Dockerfile best practices|Container orchestration basics|Networking configurations|Volume management|Security hardening|Troubleshooting techniques +EMOTIONAL INTELLIGENCE,Self-awareness development|Emotion regulation|Empathy and social awareness|Relationship management|Communication skills|Conflict resolution|Leadership effectiveness|Team dynamics +JENKINS,CI/CD pipeline creation|Build automation|Plugin management|Security configuration|Distributed builds|Pipeline as code|Integration strategies|Troubleshooting techniques +JIRA,Project management setup|Issue tracking workflows|Custom field configuration|Reporting and dashboards|Integration capabilities|User management|Automation rules|Performance optimization +KUBERNETES,Container orchestration fundamentals|Cluster architecture|Pod and service management|Configuration management|Resource management|Security best practices|Monitoring and logging|Troubleshooting techniques +PERFORMANCE METRICS,KPI identification and definition|Measurement methodologies|Data collection strategies|Analysis techniques|Reporting and visualization|Continuous monitoring|Improvement planning|Stakeholder communication +SCRUM,Scrum framework fundamentals|Role definitions|Ceremony implementation|Artifact management|Sprint execution|Backlog refinement|Team dynamics|Continuous improvement +SPLUNK,Log data ingestion|Search and analysis|Dashboard creation|Alert configuration|Data modeling|App development|Security use cases|Performance optimization +STRATEGIC THINKING,Vision development|Environmental scanning|Strategic analysis|Goal setting|Resource allocation|Risk assessment|Implementation planning|Performance measurement +PROGRAMMING SKILLS,Algorithm design|Data structure implementation|Code organization|Debugging techniques|Version control|Testing methodologies|Documentation practices|Continuous learning +STATISTICS,Descriptive statistics|Inferential statistics|Probability theory|Hypothesis testing|Regression analysis|Statistical software|Data interpretation|Research methodology +DISTRIBUTED SYSTEMS,System architecture design|Consistency models|Partitioning strategies|Replication techniques|Consensus algorithms|Fault tolerance|Performance optimization|Monitoring strategies +ORCHESTRATION,Workflow automation|Service coordination|Resource management|Dependency handling|Error recovery|Scaling strategies|Monitoring integration|Performance optimization +FLINK,Stream processing fundamentals|Event time processing|State management|Window operations|Fault tolerance|Deployment strategies|Performance tuning|Monitoring and debugging +KAFKA,Message broker architecture|Topic and partition management|Producer and consumer configuration|Stream processing|Cluster management|Security configuration|Performance optimization|Monitoring strategies +SCALA,Functional programming concepts|Object-oriented features|Type system|Collection operations|Concurrent programming|Build tools (SBT)|Testing frameworks|Performance optimization +GENERATIVE AI,Large language model concepts|Prompt engineering techniques|Fine-tuning strategies|Evaluation methodologies|Ethical considerations|Deployment strategies|Performance optimization|Use case development +CASSANDRA,NoSQL database concepts|Data modeling strategies|Cluster architecture|Replication strategies|Consistency levels|Performance tuning|Backup and recovery|Monitoring techniques +NOSQL DATABASES,Database model comparison|Document databases|Key-value stores|Column-family databases|Graph databases|Scalability patterns|Consistency models|Use case selection +NETWORKING,Network protocols|TCP/IP fundamentals|Routing and switching|Network security|Performance optimization|Troubleshooting techniques|Network design|Monitoring strategies +SPARK,Distributed computing fundamentals|RDD and DataFrame operations|Spark SQL|Streaming processing|Machine learning integration|Cluster management|Performance optimization|Debugging techniques +DATA STRUCTURES AND ALGORITHMS,Array and list operations|Tree and graph algorithms|Sorting and searching|Hash tables|Dynamic programming|Complexity analysis|Algorithm optimization|Problem-solving strategiesDJANGO,Django project structure|Model-View-Template architecture|Django ORM and database integration|URL routing and view functions|Template system and inheritance|Django admin interface|Authentication and authorization|Forms and validation|Static files and media handling|Django REST framework +FASTAPI,FastAPI application structure|Automatic API documentation|Type hints and validation|Dependency injection system|Authentication and security|Async programming support|Database integration|Testing strategies|Deployment and performance|API versioning +FLASK,Flask application structure|Routing and view functions|Jinja2 templating|Request and response handling|Session management|Blueprint organization|Database integration with SQLAlchemy|Error handling|Testing and debugging|Deployment strategies +MLOPS,Machine learning lifecycle management|Model versioning and tracking|Continuous integration for ML|Model deployment strategies|Monitoring and observability|Data pipeline automation|Feature store management|Model governance|A/B testing for models|Infrastructure automation +PYTORCH,Tensor operations and autograd|Neural network construction|Dataset and DataLoader usage|Training loop implementation|Model saving and loading|GPU acceleration|Distributed training|Custom layers and functions|Model optimization|Debugging techniques +REACT NATIVE,Cross-platform mobile development|Component architecture|Navigation implementation|State management|Native module integration|Performance optimization|Debugging and testing|App store deployment|Platform-specific code|Animation and gestures +MATHEMATICS,Linear algebra fundamentals|Calculus concepts|Statistics and probability|Discrete mathematics|Mathematical modeling|Optimization techniques|Graph theory|Number theory|Logic and proofs|Applied mathematics +ANDROID,Android app architecture|Activity and Fragment lifecycle|UI design with XML and Compose|Data storage options|Networking and APIs|Background processing|Permissions and security|Testing strategies|App publishing|Performance optimization +ERROR HANDLING,Exception handling patterns|Error logging strategies|Graceful degradation|User error messaging|Error recovery mechanisms|Debugging techniques|Error monitoring tools|Testing error scenarios|Documentation practices|Best practices +JAVA,Object-oriented programming|Java syntax and fundamentals|Collections framework|Multithreading and concurrency|Exception handling|I/O operations|Generics and annotations|Design patterns|Testing with JUnit|Build tools and IDEs +UNIT TESTING,Testing fundamentals|Test-driven development|Test case design|Mocking and stubbing|Test automation|Code coverage analysis|Integration testing|Performance testing|Testing frameworks|Continuous testing +OBJECTIVE-C,Language syntax and basics|Object-oriented concepts|Memory management|Foundation framework|Cocoa Touch integration|Interface Builder usage|Debugging techniques|Performance optimization|Legacy code maintenance|Migration strategies +COMPUTER VISION,Image processing fundamentals|Feature detection and extraction|Object recognition|Deep learning for vision|OpenCV library usage|Image classification|Object tracking|Face recognition|Medical imaging|Real-time processing +XCODE,IDE navigation and features|Project organization|Interface Builder usage|Debugging tools|Performance profiling|Version control integration|Simulator usage|App Store submission|Build configurations|Testing frameworks +RUST,Memory safety concepts|Ownership and borrowing|Error handling|Pattern matching|Concurrency primitives|Cargo package manager|Testing strategies|Performance optimization|Unsafe Rust|WebAssembly integration +SYSTEM DESIGN,Scalability patterns|Load balancing strategies|Database design choices|Caching mechanisms|Microservices architecture|API design principles|Reliability and fault tolerance|Performance optimization|Security considerations|Monitoring and observability +TELEMETRY,Data collection strategies|Metrics and logging|Distributed tracing|Performance monitoring|Error tracking|Business intelligence|Privacy considerations|Data retention policies|Visualization techniques|Alert configuration +CLOUD COMPUTING,Service models and deployment|Cost optimization strategies|Security best practices|Multi-cloud strategies|Migration planning|Disaster recovery|Compliance requirements|Performance monitoring|Resource management|Vendor evaluation +DATA MANAGEMENT,Data governance frameworks|Data quality assurance|Master data management|Data lifecycle management|Privacy and compliance|Data integration strategies|Metadata management|Data security|Backup and recovery|Performance optimization +OPERATORS,Kubernetes operator patterns|Custom resource definitions|Controller implementation|Lifecycle management|Reconciliation loops|Testing strategies|Deployment patterns|Monitoring and observability|Security considerations|Best practices +MIGRATIONS,Database schema changes|Data migration strategies|Version control for databases|Rollback procedures|Zero-downtime deployments|Testing migrations|Performance considerations|Automation tools|Documentation practices|Risk mitigation +COMBINE,Reactive programming concepts|Publisher and Subscriber|Operators and transformations|Error handling|Backpressure management|Testing strategies|Performance optimization|Integration patterns|Debugging techniques|Best practices +AZURE DEVOPS,Project management setup|Source control integration|Build pipeline configuration|Release management|Testing integration|Artifact management|Security scanning|Reporting and analytics|Integration capabilities|Automation strategies +EDITORS,Text editor features|Code syntax highlighting|Plugin and extension systems|Customization options|Keyboard shortcuts|Version control integration|Debugging integration|Performance optimization|Collaboration features|Productivity tools +INFRASTRUCTURE AS CODE,IaC principles and benefits|Terraform fundamentals|CloudFormation usage|Ansible automation|Version control integration|Testing strategies|Security scanning|Cost optimization|Documentation practices|Team collaboration +PENETRATION TESTING,Testing methodologies|Reconnaissance techniques|Vulnerability assessment|Exploitation strategies|Post-exploitation activities|Reporting procedures|Legal and ethical considerations|Tool utilization|Risk assessment|Remediation guidance +CONTAINERIZATION,Container fundamentals|Image creation and management|Registry operations|Networking configurations|Storage solutions|Security hardening|Orchestration basics|Monitoring strategies|Performance optimization|Best practices +JAVASCRIPT,Language fundamentals|DOM manipulation|Async programming|ES6+ features|Error handling|Testing strategies|Performance optimization|Security considerations|Module systems|Debugging techniques +AI,Artificial intelligence concepts|Machine learning fundamentals|Deep learning basics|Natural language processing|Computer vision applications|AI ethics and bias|Model deployment|Performance optimization|Evaluation metrics|Continuous learning +REACT,Component architecture|State management|Props and context|Event handling|Lifecycle methods|Hooks usage|Performance optimization|Testing strategies|Build and deployment|Best practices +PYTHON,Language fundamentals|Data structures|Object-oriented programming|Functional programming|Error handling|File I/O operations|Libraries and frameworks|Testing strategies|Performance optimization|Package management +TYPESCRIPT,Type system fundamentals|Interface definitions|Generic programming|Decorator usage|Module systems|Compilation process|Debugging techniques|Integration strategies|Performance considerations|Best practices +SQL,Database query fundamentals|Join operations|Subqueries and CTEs|Indexing strategies|Performance optimization|Transaction management|Security considerations|Stored procedures|Data modeling|Query analysis +COMMUNICATION SKILLS,Verbal communication|Written communication|Active listening|Presentation skills|Conflict resolution|Cross-cultural communication|Digital communication|Feedback techniques|Meeting facilitation|Stakeholder engagement +DEBUGGING,Debugging methodologies|Tool utilization|Error analysis|Performance profiling|Memory analysis|Network debugging|Security debugging|Testing integration|Documentation practices|Problem-solving strategies +WEBPACK,Module bundling concepts|Configuration setup|Loader and plugin system|Code splitting strategies|Development server|Production optimization|Asset management|Source maps|Hot module replacement|Performance optimization +C++,Language fundamentals|Object-oriented programming|Memory management|Template programming|Standard Template Library|Concurrency and parallelism|Performance optimization|Debugging techniques|Build systems|Best practices +ACCESSIBILITY,Web accessibility standards|ARIA implementation|Screen reader compatibility|Keyboard navigation|Color and contrast|Testing methodologies|Legal compliance|User experience|Development practices|Continuous improvement +ANGULAR,Component architecture|Dependency injection|Reactive forms|Routing implementation|HTTP client usage|State management|Testing strategies|Performance optimization|Build and deployment|Best practices +OBSERVABILITY,Monitoring strategies|Logging practices|Distributed tracing|Metrics collection|Alerting systems|Dashboard creation|Performance analysis|Troubleshooting techniques|Tool integration|Continuous improvement +GRAPHQL,Schema design|Query language|Resolver implementation|Performance optimization|Caching strategies|Error handling|Testing approaches|Security considerations|Federation patterns|Tool ecosystem +RELATIONAL DATABASES,Database design principles|Normalization techniques|Query optimization|Index management|Transaction handling|Backup and recovery|Performance tuning|Security configuration|Replication setup|Monitoring strategies +AZURE,Service overview|Identity management|Virtual machines|Storage solutions|Networking configuration|Security features|Cost management|Monitoring tools|Automation capabilities|Best practices +REST API,API design principles|HTTP methods and status codes|Resource modeling|Authentication strategies|Error handling|Documentation practices|Versioning strategies|Testing approaches|Performance optimization|Security considerations +DATADOG,Monitoring setup|Dashboard creation|Alert configuration|Log management|APM integration|Infrastructure monitoring|Custom metrics|Integration capabilities|Cost optimization|Best practices +D3.JS,Data visualization concepts|Selection and manipulation|Scales and axes|Layouts and generators|Animation techniques|Interaction handling|Performance optimization|Testing strategies|Integration patterns|Best practices +NODE.JS,Runtime fundamentals|Module system|Asynchronous programming|Express framework|Database integration|Error handling|Testing strategies|Performance optimization|Security considerations|Deployment practices +POSTGRESQL,Database administration|Query optimization|Index management|Replication setup|Backup strategies|Performance tuning|Security configuration|Extension usage|Monitoring techniques|Troubleshooting +VITE,Build tool fundamentals|Development server|Plugin system|Asset handling|Production optimization|TypeScript integration|Framework support|Performance features|Configuration options|Migration strategies +NEXT.JS,React framework features|Server-side rendering|Static site generation|API routes|File-based routing|Image optimization|Performance optimization|Deployment strategies|Testing approaches|Best practices +TERRAFORM,Infrastructure as code|Provider configuration|Resource management|State management|Module development|Testing strategies|Security scanning|Team collaboration|Performance optimization|Best practices +SWIFT,Language fundamentals|Object-oriented programming|Protocol-oriented programming|Memory management|Concurrency features|Error handling|Testing strategies|Performance optimization|Interoperability|Best practices +VERSION CONTROL,Git fundamentals|Branching strategies|Merge and rebase|Conflict resolution|Remote repositories|Collaborative workflows|Release management|Security considerations|Tool integration|Best practices +CYPRESS,End-to-end testing|Test automation|Browser interaction|API testing|Visual testing|Debugging techniques|CI/CD integration|Performance considerations|Test organization|Best practices +OPERATING SYSTEMS,OS fundamentals|Process management|Memory management|File systems|I/O operations|Security features|Performance optimization|System administration|Troubleshooting techniques|Virtualization +ESLINT,Code linting setup|Rule configuration|Custom rule development|Integration strategies|Performance optimization|Error handling|Team collaboration|Continuous integration|Plugin ecosystem|Best practices +LINTING,Code quality standards|Static analysis|Rule configuration|Tool integration|Automation strategies|Performance considerations|Team adoption|Continuous improvement|Error handling|Best practices +SERVICE DESIGN,Design thinking principles|User journey mapping|Service blueprinting|Stakeholder analysis|Prototyping techniques|Testing methodologies|Implementation strategies|Continuous improvement|Measurement techniques|Team collaboration +PROJECT MANAGEMENT TOOLS,Tool selection criteria|Setup and configuration|Workflow design|Team collaboration|Progress tracking|Reporting capabilities|Integration strategies|Performance optimization|User training|Best practices +A/B TESTING,Experimental design|Hypothesis formation|Statistical significance|Sample size calculation|Test implementation|Data analysis|Decision making|Continuous testing|Tool selection|Best practices +METASPLOIT,Framework architecture|Module development|Exploit execution|Payload generation|Post-exploitation|Evasion techniques|Report generation|Integration strategies|Legal considerations|Defensive applications +BURP SUITE,Web application testing|Proxy configuration|Scanner usage|Intruder attacks|Repeater functionality|Extension development|Professional features|Automation strategies|Reporting capabilities|Integration techniques +OWASP,Security framework|Top 10 vulnerabilities|Testing methodologies|Security standards|Tool recommendations|Community resources|Training materials|Compliance guidance|Risk assessment|Best practices +.NET,Framework architecture|C# programming|ASP.NET development|Entity Framework|Dependency injection|Testing strategies|Performance optimization|Security considerations|Deployment practices|Best practices +THE FUNDAMENTALS,Core concept understanding|Foundation building|Basic principle application|Skill development|Knowledge integration|Practice methodologies|Assessment techniques|Continuous learning|Problem-solving|Critical thinking +PREFERENCES,User preference management|Configuration systems|Personalization features|Settings persistence|Default handling|Migration strategies|Performance considerations|Security aspects|User experience|Testing approaches +DEEP LEARNING,Neural network architectures|Training methodologies|Optimization techniques|Regularization strategies|Transfer learning|Model evaluation|Hardware acceleration|Framework usage|Deployment strategies|Research applications +TENSORFLOW,Framework fundamentals|Model building|Training procedures|Deployment strategies|Performance optimization|TensorBoard usage|Distributed training|Custom operations|Testing approaches|Production considerations +AIRFLOW,Workflow orchestration|DAG development|Task management|Scheduling strategies|Monitoring capabilities|Error handling|Scaling techniques|Integration patterns|Security considerations|Best practices +FINE-TUNING,Model adaptation|Transfer learning|Parameter optimization|Data preparation|Training strategies|Evaluation metrics|Performance monitoring|Resource management|Deployment considerations|Continuous improvement +NLP,Natural language processing|Text preprocessing|Tokenization techniques|Language models|Sentiment analysis|Named entity recognition|Machine translation|Information extraction|Evaluation metrics|Application development +LOOKER,Data platform setup|Model development|Dashboard creation|Visualization techniques|User management|Performance optimization|Integration capabilities|Security configuration|Collaboration features|Best practices +NOTIFICATIONS,Notification systems|Delivery mechanisms|User preferences|Content personalization|Performance optimization|Privacy considerations|Testing strategies|Analytics integration|Cross-platform support|Best practices +PANDAS,Data manipulation|DataFrame operations|Data cleaning|Statistical analysis|Visualization integration|Performance optimization|Memory management|File I/O operations|Testing strategies|Best practices +TRANSFORMERS,Architecture fundamentals|Attention mechanisms|Model training|Fine-tuning techniques|Inference optimization|Framework integration|Deployment strategies|Performance monitoring|Research applications|Best practices +NUMPY,Array operations|Mathematical functions|Broadcasting concepts|Performance optimization|Memory management|Integration patterns|Vectorization techniques|Linear algebra|Random number generation|Best practices +SCIKIT-LEARN,Machine learning algorithms|Model selection|Data preprocessing|Feature engineering|Cross-validation|Performance metrics|Pipeline construction|Model persistence|Integration strategies|Best practices +HUGGINGFACE,Model hub usage|Transformer implementations|Dataset management|Training workflows|Fine-tuning procedures|Deployment strategies|Performance optimization|Community contributions|Integration patterns|Best practices +INTENT,Intent recognition|Classification techniques|Training data preparation|Model development|Evaluation metrics|Integration strategies|Performance optimization|Error handling|Continuous improvement|User experience +FLUTTER,Cross-platform development|Widget architecture|State management|Navigation implementation|Platform integration|Performance optimization|Testing strategies|Deployment procedures|Plugin development|Best practices +CORE SERVICES,Service architecture|API design|Data management|Security implementation|Performance optimization|Monitoring strategies|Scalability planning|Integration patterns|Testing approaches|Documentation practices +CIRCLECI,CI/CD pipeline setup|Workflow configuration|Build optimization|Testing integration|Deployment automation|Monitoring capabilities|Security features|Performance optimization|Team collaboration|Best practices +KANBAN,Workflow visualization|Work-in-progress limits|Continuous flow|Metrics and analytics|Team collaboration|Process improvement|Tool integration|Performance monitoring|Stakeholder communication|Best practices +CREDENTIALS,Credential management|Security practices|Storage solutions|Rotation strategies|Access controls|Audit procedures|Integration patterns|Performance considerations|Compliance requirements|Best practices +HELM,Kubernetes package management|Chart development|Release management|Template functionality|Value configuration|Repository management|Security considerations|Testing strategies|Best practices|TroubleshootingACL,Access Control List fundamentals|Permission types and inheritance|File system ACL implementation|Network ACL configuration|Active Directory ACL management|ACL troubleshooting techniques|Performance considerations|Security best practices +APT,Advanced Persistent Threat characteristics|Attack lifecycle and techniques|Attribution and threat intelligence|Detection and response strategies|Case study analysis|Defensive measures|Incident response procedures|Prevention strategies +AUTHENTICATION,Authentication factors and methods|Multi-factor authentication|Single sign-on implementation|Identity providers and federation|Authentication protocols|Token-based authentication|Biometric authentication|Risk-based authentication +Antimalware,Malware detection techniques|Signature-based vs heuristic analysis|Real-time protection mechanisms|Cloud-based threat intelligence|Performance optimization|False positive management|Enterprise deployment|Integration strategies +Antivirus,Virus detection algorithms|Scanning methodologies|Update and signature management|Quarantine procedures|Performance impact mitigation|Enterprise management|Endpoint integration|Threat response automation +Certificates,Digital certificate fundamentals|Certificate Authority hierarchy|Certificate lifecycle management|Public Key Infrastructure|Certificate validation processes|Revocation mechanisms|Certificate deployment|Troubleshooting procedures +Containment,Incident containment strategies|Network isolation techniques|System quarantine procedures|Damage limitation methods|Evidence preservation|Communication protocols|Resource allocation|Recovery planning +DATA PIPELINES,Pipeline architecture design|Data ingestion strategies|Transformation and processing|Quality assurance and validation|Monitoring and alerting|Error handling and recovery|Scalability considerations|Performance optimization +DJANGO,Django framework architecture|Model-View-Template pattern|ORM and database integration|URL routing and views|Template system and inheritance|Admin interface customization|Authentication and authorization|REST API development +DLP,Data Loss Prevention strategies|Content inspection techniques|Policy development and enforcement|Endpoint protection|Network monitoring|Cloud security integration|Incident response|Compliance reporting +EAP vs PEAP,Extensible Authentication Protocol|Protected EAP implementation|Authentication methods comparison|Wireless security integration|Certificate management|Configuration procedures|Troubleshooting techniques|Security considerations +EDR,Endpoint Detection and Response|Behavioral analysis techniques|Threat hunting capabilities|Incident response automation|Forensic data collection|Advanced threat detection|Integration with SIEM|Performance optimization +ELASTICSEARCH,Search and analytics engine|Index management and mapping|Query DSL and search operations|Cluster architecture and scaling|Data ingestion and pipelines|Monitoring and performance tuning|Security configuration|Kibana visualization +Eradication,Threat removal procedures|System cleaning and sanitization|Malware elimination techniques|Vulnerability remediation|Configuration hardening|Validation and verification|Documentation procedures|Prevention measures +Firewall & Nextgen Firewall,Traditional firewall functions|Next-generation firewall features|Application awareness and control|Intrusion prevention integration|Deep packet inspection|User identity integration|Threat intelligence feeds|Performance optimization +HIPS,Host-based Intrusion Prevention|Behavioral monitoring techniques|Policy configuration and tuning|Integration with endpoint security|Performance impact management|False positive reduction|Incident response integration|Compliance reporting +Host Based Firewall,Local firewall configuration|Rule management and policies|Application control|Network traffic filtering|Integration with security tools|Performance considerations|Troubleshooting techniques|Best practices +Identification,Threat identification techniques|Indicator analysis and correlation|Asset discovery and classification|Vulnerability identification|Risk assessment procedures|Intelligence gathering|Documentation standards|Validation processes +Kerberos,Authentication protocol fundamentals|Ticket-granting mechanisms|Key Distribution Center|Cross-realm authentication|Security considerations|Implementation best practices|Troubleshooting procedures|Integration strategies +Known vs Unknown,Threat classification methods|Signature-based detection|Zero-day threat analysis|Behavioral analysis techniques|Threat intelligence integration|Risk assessment procedures|Response strategies|Detection improvement +LDAP,Directory service fundamentals|Schema design and management|Authentication and authorization|Query operations and filters|Replication and high availability|Security configuration|Performance optimization|Integration patterns +LINUX,Operating system fundamentals|Command line proficiency|System administration|Package management|File system and permissions|Network configuration|Security hardening|Troubleshooting techniques +Lessons Learned,Post-incident analysis|Documentation procedures|Process improvement identification|Knowledge sharing mechanisms|Training development|Policy updates|Stakeholder communication|Continuous improvement +Local Auth,Local authentication methods|User account management|Password policies and enforcement|Privilege management|Security hardening|Audit and monitoring|Integration considerations|Best practices +MACHINE LEARNING,Algorithm fundamentals|Supervised and unsupervised learning|Model training and validation|Feature engineering|Performance evaluation|Deployment strategies|Ethical considerations|Continuous learning +MICROSERVICES,Architecture patterns and principles|Service decomposition strategies|Inter-service communication|Data management patterns|Deployment and orchestration|Monitoring and observability|Security considerations|Performance optimization +MYSQL,Database administration|Query optimization|Index management|Replication configuration|Backup and recovery|Performance tuning|Security hardening|Troubleshooting techniques +NIDS,Network Intrusion Detection|Traffic analysis techniques|Signature and anomaly detection|Sensor deployment strategies|Alert management and tuning|Performance optimization|Integration with SIEM|Incident response +NIPS,Network Intrusion Prevention|Inline deployment strategies|Attack blocking mechanisms|Performance considerations|Policy management|False positive reduction|High availability|Integration patterns +OAUTH,Authorization framework|Grant types and flows|Token management|Security considerations|Implementation best practices|API protection|Integration patterns|Troubleshooting procedures +POSITIONING,Strategic positioning concepts|Market analysis techniques|Competitive advantage|Brand differentiation|Value proposition development|Customer segmentation|Communication strategies|Performance measurement +POWER BI,Data visualization and analytics|Report development|Dashboard creation|Data modeling techniques|DAX formula usage|Service administration|Security and sharing|Performance optimization +Preparation,Incident response preparation|Plan development and testing|Team training and readiness|Tool and resource provisioning|Communication procedures|Documentation standards|Regular updates|Stakeholder engagement +RADIUS,Remote authentication service|Network access control|Policy enforcement|Integration strategies|Security considerations|Performance optimization|Troubleshooting techniques|High availability +REDIS,In-memory data structure store|Caching strategies|Data persistence options|Clustering and high availability|Performance optimization|Security configuration|Monitoring and troubleshooting|Integration patterns +Recovery,Disaster recovery planning|Backup and restoration|Business continuity|System recovery procedures|Data recovery techniques|Testing and validation|Communication protocols|Continuous improvement +SSO,Single Sign-On implementation|Identity provider integration|Federation protocols|Security considerations|User experience optimization|Administration and management|Troubleshooting procedures|Performance considerations +Sandboxing,Isolated execution environments|Malware analysis techniques|Application security testing|Performance impact assessment|Evasion detection|Integration strategies|Automation procedures|Result analysis +Security Skills and Knowledge,Cybersecurity fundamentals|Threat landscape awareness|Risk assessment methodologies|Security framework knowledge|Incident response capabilities|Compliance requirements|Continuous learning|Professional development +TABLEAU,Data visualization platform|Dashboard development|Data connection and modeling|Calculated fields and parameters|Interactive features|Performance optimization|Administration and security|Advanced analytics +Understand Basics of Forensics,Digital evidence principles|Chain of custody procedures|Forensic methodologies|Tool utilization|Legal considerations|Report writing|Expert testimony|Continuous education +Understand Common Exploit Frameworks,Framework architecture|Payload development|Target exploitation|Post-exploitation techniques|Evasion methods|Defensive considerations|Legal and ethical usage|Tool integration +Understand Common Hacking Tools,Tool categories and purposes|Reconnaissance tools|Exploitation frameworks|Post-exploitation utilities|Defensive applications|Legal considerations|Tool detection|Mitigation strategies +Understand Concept of Defense in Depth,Layered security approach|Security control categories|Risk mitigation strategies|Implementation planning|Integration considerations|Effectiveness measurement|Continuous improvement|Cost-benefit analysis +Understand Concept of Runbooks,Procedure documentation|Incident response playbooks|Operational procedures|Automation integration|Version control|Training materials|Regular updates|Effectiveness measurement +VirusTotal,File and URL analysis|Threat intelligence aggregation|API integration|Report interpretation|Automation workflows|Threat hunting applications|False positive management|Enterprise features +WPA vs WPA2 vs WPA3 vs WEP,Wireless security protocol evolution|Encryption method comparison|Authentication mechanisms|Vulnerability analysis|Implementation considerations|Performance impact|Migration strategies|Best practices +WPS,Wi-Fi Protected Setup|Security vulnerabilities|Attack vectors|Disable procedures|Alternative setup methods|Security implications|Troubleshooting|Best practices +Zero Day,Unknown vulnerability exploitation|Discovery and disclosure|Attack techniques|Detection challenges|Mitigation strategies|Threat intelligence|Response procedures|Prevention measures \ No newline at end of file diff --git a/backend/Using/__pycache__/database.cpython-314.pyc b/backend/Using/__pycache__/database.cpython-314.pyc new file mode 100644 index 00000000..9fee8783 Binary files /dev/null and b/backend/Using/__pycache__/database.cpython-314.pyc differ diff --git a/backend/Using/__pycache__/main.cpython-314.pyc b/backend/Using/__pycache__/main.cpython-314.pyc new file mode 100644 index 00000000..31873472 Binary files /dev/null and b/backend/Using/__pycache__/main.cpython-314.pyc differ diff --git a/backend/Using/__pycache__/models.cpython-314.pyc b/backend/Using/__pycache__/models.cpython-314.pyc new file mode 100644 index 00000000..a8dddb44 Binary files /dev/null and b/backend/Using/__pycache__/models.cpython-314.pyc differ diff --git a/backend/Using/backup_neo4j.py b/backend/Using/backup_neo4j.py new file mode 100644 index 00000000..27c2246f --- /dev/null +++ b/backend/Using/backup_neo4j.py @@ -0,0 +1,56 @@ +"""Export all Neo4j nodes and relationships to a JSON snapshot.""" +import sys +import json +import gzip +from datetime import datetime +from pathlib import Path + +sys.stdout.reconfigure(encoding='utf-8') +from database import Neo4jDriver + +driver = Neo4jDriver.get_driver() +output_dir = Path(__file__).parent / "output" / "backups" +output_dir.mkdir(parents=True, exist_ok=True) + +timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") +out_file = output_dir / f"neo4j_backup_{timestamp}.json.gz" + +print("Exporting nodes...") +nodes = [] +with driver.session() as s: + result = s.run("MATCH (n) RETURN elementId(n) AS id, labels(n) AS labels, properties(n) AS props") + for r in result: + nodes.append({"id": r["id"], "labels": r["labels"], "props": dict(r["props"])}) +print(f" {len(nodes)} nodes") + +print("Exporting relationships...") +rels = [] +with driver.session() as s: + result = s.run( + "MATCH (a)-[r]->(b) " + "RETURN elementId(r) AS id, type(r) AS type, " + "elementId(a) AS from_id, elementId(b) AS to_id, properties(r) AS props" + ) + for r in result: + rels.append({ + "id": r["id"], "type": r["type"], + "from": r["from_id"], "to": r["to_id"], + "props": dict(r["props"]) + }) +print(f" {len(rels)} relationships") + +snapshot = { + "created_at": datetime.now().isoformat(), + "node_count": len(nodes), + "rel_count": len(rels), + "nodes": nodes, + "relationships": rels, +} + +with gzip.open(out_file, "wt", encoding="utf-8") as f: + json.dump(snapshot, f, ensure_ascii=False, indent=2) + +size_kb = out_file.stat().st_size // 1024 +print(f"\nSaved: {out_file}") +print(f"Size: {size_kb} KB") +print(f"Nodes: {len(nodes)}, Rels: {len(rels)}") diff --git a/backend/Using/data/mock_db.json b/backend/Using/data/mock_db.json new file mode 100644 index 00000000..e25908e6 --- /dev/null +++ b/backend/Using/data/mock_db.json @@ -0,0 +1,6394 @@ +{ + "users": [ + { + "id": "u-001", + "email": "alex.morgan@example.com", + "name": "Alex Morgan", + "image_url": null, + "github_username": "OhamjDung", + "xp_total": 2455, + "current_streak": 1, + "longest_streak": 31, + "onboarding_completed": true, + "onboarding_step": 5, + "created_at": "2025-09-01T00:00:00Z", + "last_active_date": "2026-04-28", + "character": { + "skin": "char1.png", + "eyes": "eyes.png", + "clothes": "suit.png", + "pants": "pants.png", + "shoes": "shoes.png", + "hair": "wavy.png", + "accessories": "", + "color_variants": {} + } + } + ], + "roles": [ + { + "id": "r-001", + "title": "Front End Developer", + "domain": "Software Engineering" + }, + { + "id": "r-002", + "title": "Full Stack Developer", + "domain": "Software Engineering" + }, + { + "id": "r-003", + "title": "Data Scientist", + "domain": "Machine Learning" + }, + { + "id": "r-004", + "title": "UX Designer", + "domain": "Design" + } + ], + "companies": [ + { + "id": "c-001", + "name": "Google", + "logo_url": null + }, + { + "id": "c-002", + "name": "Meta", + "logo_url": null + }, + { + "id": "c-003", + "name": "Stripe", + "logo_url": null + } + ], + "user_target_roles": [ + { + "id": "utr-001", + "user_id": "u-001", + "role_id": "r-001", + "is_primary": true + } + ], + "user_target_companies": [ + { + "id": "utc-001", + "user_id": "u-001", + "company_id": "c-001" + }, + { + "id": "utc-002", + "user_id": "u-001", + "company_id": "c-002" + } + ], + "user_learning_preferences": [ + { + "id": "ulp-001", + "user_id": "u-001", + "daily_hours": 2, + "preferred_format": "video", + "difficulty": "intermediate" + } + ], + "skills": [ + { + "id": "sk-001", + "name": "HTML", + "category": "markup" + }, + { + "id": "sk-002", + "name": "CSS", + "category": "styling" + }, + { + "id": "sk-003", + "name": "JavaScript", + "category": "language" + }, + { + "id": "sk-004", + "name": "React", + "category": "framework" + }, + { + "id": "sk-005", + "name": "Python", + "category": "language" + } + ], + "user_skills": [ + { + "id": "us-001", + "user_id": "u-001", + "skill_id": "sk-001", + "proficiency": 0.9 + }, + { + "id": "us-002", + "user_id": "u-001", + "skill_id": "sk-002", + "proficiency": 0.8 + }, + { + "id": "us-003", + "user_id": "u-001", + "skill_id": "sk-003", + "proficiency": 0.6 + } + ], + "roadmaps": [ + { + "id": "rm-generated", + "user_id": "u-001", + "title": "Full-Stack Engineer Roadmap", + "progress_percentage": 0, + "status": "active" + }, + { + "id": "rm-001", + "user_id": "u-001", + "role_id": "r-001", + "title": "Front End Developer", + "status": "active", + "progress_percentage": 68 + }, + { + "id": "rm-002", + "user_id": "u-001", + "role_id": "r-002", + "title": "Full Stack Developer", + "status": "not_started", + "progress_percentage": 12 + }, + { + "id": "rm-003", + "user_id": "u-001", + "role_id": "r-003", + "title": "Data Science", + "status": "not_started", + "progress_percentage": 0 + }, + { + "id": "rm-004", + "user_id": "u-001", + "role_id": "r-004", + "title": "UX Design", + "status": "not_started", + "progress_percentage": 45 + } + ], + "roadmap_checkpoints": [ + { + "id": "cp-001", + "roadmap_id": "rm-001", + "label": "HTML5 Foundations", + "kind": "lesson", + "progress": 100, + "locked": false, + "position": { + "x": 0, + "y": 150 + }, + "description": "Master the building blocks of the web. You'll learn how browsers parse HTML, semantic element choices that affect SEO and accessibility, and how to structure a document that's both human-readable and machine-friendly.", + "learning_goals": [ + "Understand the role of semantic HTML elements (header, main, article, section)", + "Build well-structured forms with proper labels and input types", + "Apply accessibility best practices using ARIA roles and alt text", + "Validate HTML using the W3C validator and fix common errors" + ] + }, + { + "id": "cp-002", + "roadmap_id": "rm-001", + "label": "Advanced CSS & Grid", + "kind": "lesson", + "progress": 100, + "locked": false, + "position": { + "x": 300, + "y": 150 + }, + "description": "Go beyond basic styling. This checkpoint covers CSS Grid and Flexbox layouts, responsive design with media queries, CSS custom properties (variables), and modern techniques like clamp() and container queries.", + "learning_goals": [ + "Build complex two-dimensional layouts using CSS Grid", + "Create flexible, one-dimensional layouts with Flexbox", + "Write responsive styles using media queries and fluid units", + "Use CSS custom properties to build a maintainable design token system" + ] + }, + { + "id": "cp-003", + "roadmap_id": "rm-001", + "label": "Layouts Master Quiz", + "kind": "quiz", + "progress": 100, + "locked": false, + "position": { + "x": 600, + "y": 150 + }, + "description": "Test your knowledge of HTML structure and CSS layouts. This quiz covers semantic markup, Flexbox, Grid, and responsive design patterns encountered in real-world projects.", + "learning_goals": [ + "Recall the difference between block, inline, and inline-block elements", + "Identify correct Grid and Flexbox properties for given layout challenges", + "Diagnose and fix common layout bugs", + "Apply media query breakpoints to a given design spec" + ] + }, + { + "id": "cp-004", + "roadmap_id": "rm-001", + "label": "JS Logic & Variables", + "kind": "lesson", + "progress": 100, + "locked": false, + "position": { + "x": 900, + "y": 50 + }, + "description": "Learn the fundamentals of JavaScript: data types, variable scoping (var vs let vs const), operators, control flow, and functions. This is the foundation for all JS-powered interactivity.", + "learning_goals": [ + "Distinguish between let, const, and var and when to use each", + "Write functions using both declaration and arrow-function syntax", + "Control program flow using if/else, switch, and ternary expressions", + "Understand truthy/falsy values and short-circuit evaluation" + ] + }, + { + "id": "cp-005", + "roadmap_id": "rm-001", + "label": "DOM & Events", + "kind": "lesson", + "progress": 100, + "locked": false, + "position": { + "x": 900, + "y": 250 + }, + "description": "Bring web pages to life by manipulating the DOM and responding to user events. Covers querySelector, event listeners, event propagation, and the difference between innerHTML and textContent.", + "learning_goals": [ + "Select and modify DOM elements using querySelector and querySelectorAll", + "Attach and remove event listeners for user interactions", + "Explain event bubbling and capture, and use stopPropagation when needed", + "Dynamically create and remove elements from the page" + ] + }, + { + "id": "cp-006", + "roadmap_id": "rm-001", + "label": "Interactive Site Project", + "kind": "project", + "progress": 40, + "locked": false, + "position": { + "x": 1250, + "y": 150 + }, + "description": "Apply everything learned so far to build a small interactive website \u2014 a to-do list, a quiz app, or a weather dashboard. Focus on clean HTML structure, responsive CSS, and vanilla JS logic with no frameworks.", + "learning_goals": [ + "Plan a small project by breaking it into HTML structure, CSS styles, and JS logic", + "Implement CRUD operations (add, edit, delete items) using DOM manipulation", + "Persist data across page reloads using localStorage", + "Deploy the project to GitHub Pages or Netlify" + ] + }, + { + "id": "cp-007", + "roadmap_id": "rm-001", + "label": "Asynchronous JS", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 1550, + "y": 150 + }, + "description": "Understand how JavaScript handles async operations: the event loop, callbacks, Promises, and async/await syntax. Learn to fetch data from APIs and handle loading and error states gracefully.", + "learning_goals": [ + "Explain the JavaScript event loop and call stack", + "Chain Promises using .then()/.catch() and convert to async/await", + "Fetch data from a public REST API and render it in the DOM", + "Handle network errors and display appropriate user feedback" + ] + }, + { + "id": "cp-008", + "roadmap_id": "rm-001", + "label": "React Fundamentals", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 1850, + "y": 150 + }, + "description": "Introduction to React: JSX syntax, functional components, props, and the useState and useEffect hooks. Build a small component-driven UI and understand the virtual DOM and reconciliation.", + "learning_goals": [ + "Write functional components using JSX and pass data via props", + "Manage local component state with the useState hook", + "Trigger side effects and data fetching with useEffect", + "Compose a multi-component page with a clear data-flow hierarchy" + ] + }, + { + "id": "cp-gen-000", + "roadmap_id": "rm-generated", + "label": "Programming Fundamentals", + "kind": "lesson", + "progress": 0, + "locked": false, + "position": { + "x": 300, + "y": 100 + }, + "description": "Learn the key concepts of Programming Fundamentals.", + "learning_goals": [ + "Understand the core principles of Programming Fundamentals", + "Apply Programming Fundamentals in practical scenarios", + "Explore advanced patterns in Programming Fundamentals", + "Build something real using Programming Fundamentals" + ] + }, + { + "id": "cp-gen-001", + "roadmap_id": "rm-generated", + "label": "Internet", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 230 + }, + "description": "Learn the key concepts of Internet.", + "learning_goals": [ + "Understand the core principles of Internet", + "Apply Internet in practical scenarios", + "Explore advanced patterns in Internet", + "Build something real using Internet" + ] + }, + { + "id": "cp-gen-002", + "roadmap_id": "rm-generated", + "label": "Internet Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 360 + }, + "description": "Learn the key concepts of Internet Quiz.", + "learning_goals": [ + "Understand the core principles of Internet Quiz", + "Apply Internet Quiz in practical scenarios", + "Explore advanced patterns in Internet Quiz", + "Build something real using Internet Quiz" + ] + }, + { + "id": "cp-gen-003", + "roadmap_id": "rm-generated", + "label": "Basics of Probability", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 490 + }, + "description": "Learn the key concepts of Basics of Probability.", + "learning_goals": [ + "Understand the core principles of Basics of Probability", + "Apply Basics of Probability in practical scenarios", + "Explore advanced patterns in Basics of Probability", + "Build something real using Basics of Probability" + ] + }, + { + "id": "cp-gen-004", + "roadmap_id": "rm-generated", + "label": "Bayes Theorem", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 620 + }, + "description": "Learn the key concepts of Bayes Theorem.", + "learning_goals": [ + "Understand the core principles of Bayes Theorem", + "Apply Bayes Theorem in practical scenarios", + "Explore advanced patterns in Bayes Theorem", + "Build something real using Bayes Theorem" + ] + }, + { + "id": "cp-gen-005", + "roadmap_id": "rm-generated", + "label": "Random Variances, PDFs", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 750 + }, + "description": "Learn the key concepts of Random Variances, PDFs.", + "learning_goals": [ + "Understand the core principles of Random Variances, PDFs", + "Apply Random Variances, PDFs in practical scenarios", + "Explore advanced patterns in Random Variances, PDFs", + "Build something real using Random Variances, PDFs" + ] + }, + { + "id": "cp-gen-006", + "roadmap_id": "rm-generated", + "label": "Object Oriented Programming", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 880 + }, + "description": "Learn the key concepts of Object Oriented Programming.", + "learning_goals": [ + "Understand the core principles of Object Oriented Programming", + "Apply Object Oriented Programming in practical scenarios", + "Explore advanced patterns in Object Oriented Programming", + "Build something real using Object Oriented Programming" + ] + }, + { + "id": "cp-gen-007", + "roadmap_id": "rm-generated", + "label": "Object Oriented Programming Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 1010 + }, + "description": "Learn the key concepts of Object Oriented Programming Quiz.", + "learning_goals": [ + "Understand the core principles of Object Oriented Programming Quiz", + "Apply Object Oriented Programming Quiz in practical scenarios", + "Explore advanced patterns in Object Oriented Programming Quiz", + "Build something real using Object Oriented Programming Quiz" + ] + }, + { + "id": "cp-gen-008", + "roadmap_id": "rm-generated", + "label": "Basic Syntax", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 1140 + }, + "description": "Learn the key concepts of Basic Syntax.", + "learning_goals": [ + "Understand the core principles of Basic Syntax", + "Apply Basic Syntax in practical scenarios", + "Explore advanced patterns in Basic Syntax", + "Build something real using Basic Syntax" + ] + }, + { + "id": "cp-gen-009", + "roadmap_id": "rm-generated", + "label": "Matplotlib", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 1270 + }, + "description": "Learn the key concepts of Matplotlib.", + "learning_goals": [ + "Understand the core principles of Matplotlib", + "Apply Matplotlib in practical scenarios", + "Explore advanced patterns in Matplotlib", + "Build something real using Matplotlib" + ] + }, + { + "id": "cp-gen-010", + "roadmap_id": "rm-generated", + "label": "Numpy", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 1400 + }, + "description": "Learn the key concepts of Numpy.", + "learning_goals": [ + "Understand the core principles of Numpy", + "Apply Numpy in practical scenarios", + "Explore advanced patterns in Numpy", + "Build something real using Numpy" + ] + }, + { + "id": "cp-gen-011", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #1", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 1530 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #1.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #1", + "Apply Full-Stack Engineer Project #1 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #1", + "Build something real using Full-Stack Engineer Project #1" + ] + }, + { + "id": "cp-gen-012", + "roadmap_id": "rm-generated", + "label": "Variables and Data Types", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 1660 + }, + "description": "Learn the key concepts of Variables and Data Types.", + "learning_goals": [ + "Understand the core principles of Variables and Data Types", + "Apply Variables and Data Types in practical scenarios", + "Explore advanced patterns in Variables and Data Types", + "Build something real using Variables and Data Types" + ] + }, + { + "id": "cp-gen-013", + "roadmap_id": "rm-generated", + "label": "Seaborn", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 1790 + }, + "description": "Learn the key concepts of Seaborn.", + "learning_goals": [ + "Understand the core principles of Seaborn", + "Apply Seaborn in practical scenarios", + "Explore advanced patterns in Seaborn", + "Build something real using Seaborn" + ] + }, + { + "id": "cp-gen-014", + "roadmap_id": "rm-generated", + "label": "Seaborn Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 1920 + }, + "description": "Learn the key concepts of Seaborn Quiz.", + "learning_goals": [ + "Understand the core principles of Seaborn Quiz", + "Apply Seaborn Quiz in practical scenarios", + "Explore advanced patterns in Seaborn Quiz", + "Build something real using Seaborn Quiz" + ] + }, + { + "id": "cp-gen-015", + "roadmap_id": "rm-generated", + "label": "Pandas", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 2050 + }, + "description": "Learn the key concepts of Pandas.", + "learning_goals": [ + "Understand the core principles of Pandas", + "Apply Pandas in practical scenarios", + "Explore advanced patterns in Pandas", + "Build something real using Pandas" + ] + }, + { + "id": "cp-gen-016", + "roadmap_id": "rm-generated", + "label": "Data Structures", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 2180 + }, + "description": "Learn the key concepts of Data Structures.", + "learning_goals": [ + "Understand the core principles of Data Structures", + "Apply Data Structures in practical scenarios", + "Explore advanced patterns in Data Structures", + "Build something real using Data Structures" + ] + }, + { + "id": "cp-gen-017", + "roadmap_id": "rm-generated", + "label": "Loops", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 2310 + }, + "description": "Learn the key concepts of Loops.", + "learning_goals": [ + "Understand the core principles of Loops", + "Apply Loops in practical scenarios", + "Explore advanced patterns in Loops", + "Build something real using Loops" + ] + }, + { + "id": "cp-gen-018", + "roadmap_id": "rm-generated", + "label": "Essential libraries", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 2440 + }, + "description": "Learn the key concepts of Essential libraries.", + "learning_goals": [ + "Understand the core principles of Essential libraries", + "Apply Essential libraries in practical scenarios", + "Explore advanced patterns in Essential libraries", + "Build something real using Essential libraries" + ] + }, + { + "id": "cp-gen-019", + "roadmap_id": "rm-generated", + "label": "Essential libraries Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 2570 + }, + "description": "Learn the key concepts of Essential libraries Quiz.", + "learning_goals": [ + "Understand the core principles of Essential libraries Quiz", + "Apply Essential libraries Quiz in practical scenarios", + "Explore advanced patterns in Essential libraries Quiz", + "Build something real using Essential libraries Quiz" + ] + }, + { + "id": "cp-gen-020", + "roadmap_id": "rm-generated", + "label": "APIs", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 2700 + }, + "description": "Learn the key concepts of APIs.", + "learning_goals": [ + "Understand the core principles of APIs", + "Apply APIs in practical scenarios", + "Explore advanced patterns in APIs", + "Build something real using APIs" + ] + }, + { + "id": "cp-gen-021", + "roadmap_id": "rm-generated", + "label": "Conditionals", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 2830 + }, + "description": "Learn the key concepts of Conditionals.", + "learning_goals": [ + "Understand the core principles of Conditionals", + "Apply Conditionals in practical scenarios", + "Explore advanced patterns in Conditionals", + "Build something real using Conditionals" + ] + }, + { + "id": "cp-gen-022", + "roadmap_id": "rm-generated", + "label": "IoT", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 2960 + }, + "description": "Learn the key concepts of IoT.", + "learning_goals": [ + "Understand the core principles of IoT", + "Apply IoT in practical scenarios", + "Explore advanced patterns in IoT", + "Build something real using IoT" + ] + }, + { + "id": "cp-gen-023", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #2", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 3090 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #2.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #2", + "Apply Full-Stack Engineer Project #2 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #2", + "Build something real using Full-Stack Engineer Project #2" + ] + }, + { + "id": "cp-gen-024", + "roadmap_id": "rm-generated", + "label": "Exceptions", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 3220 + }, + "description": "Learn the key concepts of Exceptions.", + "learning_goals": [ + "Understand the core principles of Exceptions", + "Apply Exceptions in practical scenarios", + "Explore advanced patterns in Exceptions", + "Build something real using Exceptions" + ] + }, + { + "id": "cp-gen-025", + "roadmap_id": "rm-generated", + "label": "Functions, Builtin Functions", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 3350 + }, + "description": "Learn the key concepts of Functions, Builtin Functions.", + "learning_goals": [ + "Understand the core principles of Functions, Builtin Functions", + "Apply Functions, Builtin Functions in practical scenarios", + "Explore advanced patterns in Functions, Builtin Functions", + "Build something real using Functions, Builtin Functions" + ] + }, + { + "id": "cp-gen-026", + "roadmap_id": "rm-generated", + "label": "Preprocessing Techniques", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 3480 + }, + "description": "Learn the key concepts of Preprocessing Techniques.", + "learning_goals": [ + "Understand the core principles of Preprocessing Techniques", + "Apply Preprocessing Techniques in practical scenarios", + "Explore advanced patterns in Preprocessing Techniques", + "Build something real using Preprocessing Techniques" + ] + }, + { + "id": "cp-gen-027", + "roadmap_id": "rm-generated", + "label": "Preprocessing Techniques Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 3610 + }, + "description": "Learn the key concepts of Preprocessing Techniques Quiz.", + "learning_goals": [ + "Understand the core principles of Preprocessing Techniques Quiz", + "Apply Preprocessing Techniques Quiz in practical scenarios", + "Explore advanced patterns in Preprocessing Techniques Quiz", + "Build something real using Preprocessing Techniques Quiz" + ] + }, + { + "id": "cp-gen-028", + "roadmap_id": "rm-generated", + "label": "Data Cleaning", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 3740 + }, + "description": "Learn the key concepts of Data Cleaning.", + "learning_goals": [ + "Understand the core principles of Data Cleaning", + "Apply Data Cleaning in practical scenarios", + "Explore advanced patterns in Data Cleaning", + "Build something real using Data Cleaning" + ] + }, + { + "id": "cp-gen-029", + "roadmap_id": "rm-generated", + "label": "Excel", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 3870 + }, + "description": "Learn the key concepts of Excel.", + "learning_goals": [ + "Understand the core principles of Excel", + "Apply Excel in practical scenarios", + "Explore advanced patterns in Excel", + "Build something real using Excel" + ] + }, + { + "id": "cp-gen-030", + "roadmap_id": "rm-generated", + "label": "Excel Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 4000 + }, + "description": "Learn the key concepts of Excel Quiz.", + "learning_goals": [ + "Understand the core principles of Excel Quiz", + "Apply Excel Quiz in practical scenarios", + "Explore advanced patterns in Excel Quiz", + "Build something real using Excel Quiz" + ] + }, + { + "id": "cp-gen-031", + "roadmap_id": "rm-generated", + "label": "Feature Engineering", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 4130 + }, + "description": "Learn the key concepts of Feature Engineering.", + "learning_goals": [ + "Understand the core principles of Feature Engineering", + "Apply Feature Engineering in practical scenarios", + "Explore advanced patterns in Feature Engineering", + "Build something real using Feature Engineering" + ] + }, + { + "id": "cp-gen-032", + "roadmap_id": "rm-generated", + "label": "Parquet", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 4260 + }, + "description": "Learn the key concepts of Parquet.", + "learning_goals": [ + "Understand the core principles of Parquet", + "Apply Parquet in practical scenarios", + "Explore advanced patterns in Parquet", + "Build something real using Parquet" + ] + }, + { + "id": "cp-gen-033", + "roadmap_id": "rm-generated", + "label": "Feature Scaling & Normalization", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 4390 + }, + "description": "Learn the key concepts of Feature Scaling & Normalization.", + "learning_goals": [ + "Understand the core principles of Feature Scaling & Normalization", + "Apply Feature Scaling & Normalization in practical scenarios", + "Explore advanced patterns in Feature Scaling & Normalization", + "Build something real using Feature Scaling & Normalization" + ] + }, + { + "id": "cp-gen-034", + "roadmap_id": "rm-generated", + "label": "Type Checkers", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 4520 + }, + "description": "Learn the key concepts of Type Checkers.", + "learning_goals": [ + "Understand the core principles of Type Checkers", + "Apply Type Checkers in practical scenarios", + "Explore advanced patterns in Type Checkers", + "Build something real using Type Checkers" + ] + }, + { + "id": "cp-gen-035", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #3", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 4650 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #3.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #3", + "Apply Full-Stack Engineer Project #3 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #3", + "Build something real using Full-Stack Engineer Project #3" + ] + }, + { + "id": "cp-gen-036", + "roadmap_id": "rm-generated", + "label": "What is Machine Learning?", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 4780 + }, + "description": "Learn the key concepts of What is Machine Learning?.", + "learning_goals": [ + "Understand the core principles of What is Machine Learning?", + "Apply What is Machine Learning? in practical scenarios", + "Explore advanced patterns in What is Machine Learning?", + "Build something real using What is Machine Learning?" + ] + }, + { + "id": "cp-gen-037", + "roadmap_id": "rm-generated", + "label": "Feature Selection", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 4910 + }, + "description": "Learn the key concepts of Feature Selection.", + "learning_goals": [ + "Understand the core principles of Feature Selection", + "Apply Feature Selection in practical scenarios", + "Explore advanced patterns in Feature Selection", + "Build something real using Feature Selection" + ] + }, + { + "id": "cp-gen-038", + "roadmap_id": "rm-generated", + "label": "Feature Selection Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 5040 + }, + "description": "Learn the key concepts of Feature Selection Quiz.", + "learning_goals": [ + "Understand the core principles of Feature Selection Quiz", + "Apply Feature Selection Quiz in practical scenarios", + "Explore advanced patterns in Feature Selection Quiz", + "Build something real using Feature Selection Quiz" + ] + }, + { + "id": "cp-gen-039", + "roadmap_id": "rm-generated", + "label": "SSR", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 5170 + }, + "description": "Learn the key concepts of SSR.", + "learning_goals": [ + "Understand the core principles of SSR", + "Apply SSR in practical scenarios", + "Explore advanced patterns in SSR", + "Build something real using SSR" + ] + }, + { + "id": "cp-gen-040", + "roadmap_id": "rm-generated", + "label": "GraphQL", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 5300 + }, + "description": "Learn the key concepts of GraphQL.", + "learning_goals": [ + "Understand the core principles of GraphQL", + "Apply GraphQL in practical scenarios", + "Explore advanced patterns in GraphQL", + "Build something real using GraphQL" + ] + }, + { + "id": "cp-gen-041", + "roadmap_id": "rm-generated", + "label": "GraphQL Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 5430 + }, + "description": "Learn the key concepts of GraphQL Quiz.", + "learning_goals": [ + "Understand the core principles of GraphQL Quiz", + "Apply GraphQL Quiz in practical scenarios", + "Explore advanced patterns in GraphQL Quiz", + "Build something real using GraphQL Quiz" + ] + }, + { + "id": "cp-gen-042", + "roadmap_id": "rm-generated", + "label": "PWAs", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 5560 + }, + "description": "Learn the key concepts of PWAs.", + "learning_goals": [ + "Understand the core principles of PWAs", + "Apply PWAs in practical scenarios", + "Explore advanced patterns in PWAs", + "Build something real using PWAs" + ] + }, + { + "id": "cp-gen-043", + "roadmap_id": "rm-generated", + "label": "Static Site Generators", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 5690 + }, + "description": "Learn the key concepts of Static Site Generators.", + "learning_goals": [ + "Understand the core principles of Static Site Generators", + "Apply Static Site Generators in practical scenarios", + "Explore advanced patterns in Static Site Generators", + "Build something real using Static Site Generators" + ] + }, + { + "id": "cp-gen-044", + "roadmap_id": "rm-generated", + "label": "Mobile Apps", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 5820 + }, + "description": "Learn the key concepts of Mobile Apps.", + "learning_goals": [ + "Understand the core principles of Mobile Apps", + "Apply Mobile Apps in practical scenarios", + "Explore advanced patterns in Mobile Apps", + "Build something real using Mobile Apps" + ] + }, + { + "id": "cp-gen-045", + "roadmap_id": "rm-generated", + "label": "Polynomial Regression", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 5950 + }, + "description": "Learn the key concepts of Polynomial Regression.", + "learning_goals": [ + "Understand the core principles of Polynomial Regression", + "Apply Polynomial Regression in practical scenarios", + "Explore advanced patterns in Polynomial Regression", + "Build something real using Polynomial Regression" + ] + }, + { + "id": "cp-gen-046", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #4", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 6080 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #4.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #4", + "Apply Full-Stack Engineer Project #4 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #4", + "Build something real using Full-Stack Engineer Project #4" + ] + }, + { + "id": "cp-gen-047", + "roadmap_id": "rm-generated", + "label": "Ridge", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 6210 + }, + "description": "Learn the key concepts of Ridge.", + "learning_goals": [ + "Understand the core principles of Ridge", + "Apply Ridge in practical scenarios", + "Explore advanced patterns in Ridge", + "Build something real using Ridge" + ] + }, + { + "id": "cp-gen-048", + "roadmap_id": "rm-generated", + "label": "Lasso", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 6340 + }, + "description": "Learn the key concepts of Lasso.", + "learning_goals": [ + "Understand the core principles of Lasso", + "Apply Lasso in practical scenarios", + "Explore advanced patterns in Lasso", + "Build something real using Lasso" + ] + }, + { + "id": "cp-gen-049", + "roadmap_id": "rm-generated", + "label": "What is Unsupervised Learning?", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 6470 + }, + "description": "Learn the key concepts of What is Unsupervised Learning?.", + "learning_goals": [ + "Understand the core principles of What is Unsupervised Learning?", + "Apply What is Unsupervised Learning? in practical scenarios", + "Explore advanced patterns in What is Unsupervised Learning?", + "Build something real using What is Unsupervised Learning?" + ] + }, + { + "id": "cp-gen-050", + "roadmap_id": "rm-generated", + "label": "What is Unsupervised Learning? Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 6600 + }, + "description": "Learn the key concepts of What is Unsupervised Learning? Quiz.", + "learning_goals": [ + "Understand the core principles of What is Unsupervised Learning? Quiz", + "Apply What is Unsupervised Learning? Quiz in practical scenarios", + "Explore advanced patterns in What is Unsupervised Learning? Quiz", + "Build something real using What is Unsupervised Learning? Quiz" + ] + }, + { + "id": "cp-gen-051", + "roadmap_id": "rm-generated", + "label": "ElasticNet Regularization", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 6730 + }, + "description": "Learn the key concepts of ElasticNet Regularization.", + "learning_goals": [ + "Understand the core principles of ElasticNet Regularization", + "Apply ElasticNet Regularization in practical scenarios", + "Explore advanced patterns in ElasticNet Regularization", + "Build something real using ElasticNet Regularization" + ] + }, + { + "id": "cp-gen-052", + "roadmap_id": "rm-generated", + "label": "Clustering", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 6860 + }, + "description": "Learn the key concepts of Clustering.", + "learning_goals": [ + "Understand the core principles of Clustering", + "Apply Clustering in practical scenarios", + "Explore advanced patterns in Clustering", + "Build something real using Clustering" + ] + }, + { + "id": "cp-gen-053", + "roadmap_id": "rm-generated", + "label": "Clustering Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 6990 + }, + "description": "Learn the key concepts of Clustering Quiz.", + "learning_goals": [ + "Understand the core principles of Clustering Quiz", + "Apply Clustering Quiz in practical scenarios", + "Explore advanced patterns in Clustering Quiz", + "Build something real using Clustering Quiz" + ] + }, + { + "id": "cp-gen-054", + "roadmap_id": "rm-generated", + "label": "Dimensionality Reduction", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 7120 + }, + "description": "Learn the key concepts of Dimensionality Reduction.", + "learning_goals": [ + "Understand the core principles of Dimensionality Reduction", + "Apply Dimensionality Reduction in practical scenarios", + "Explore advanced patterns in Dimensionality Reduction", + "Build something real using Dimensionality Reduction" + ] + }, + { + "id": "cp-gen-055", + "roadmap_id": "rm-generated", + "label": "Exclusive", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 7250 + }, + "description": "Learn the key concepts of Exclusive.", + "learning_goals": [ + "Understand the core principles of Exclusive", + "Apply Exclusive in practical scenarios", + "Explore advanced patterns in Exclusive", + "Build something real using Exclusive" + ] + }, + { + "id": "cp-gen-056", + "roadmap_id": "rm-generated", + "label": "Principal Component Analysis", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 7380 + }, + "description": "Learn the key concepts of Principal Component Analysis.", + "learning_goals": [ + "Understand the core principles of Principal Component Analysis", + "Apply Principal Component Analysis in practical scenarios", + "Explore advanced patterns in Principal Component Analysis", + "Build something real using Principal Component Analysis" + ] + }, + { + "id": "cp-gen-057", + "roadmap_id": "rm-generated", + "label": "Overlapping", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 7510 + }, + "description": "Learn the key concepts of Overlapping.", + "learning_goals": [ + "Understand the core principles of Overlapping", + "Apply Overlapping in practical scenarios", + "Explore advanced patterns in Overlapping", + "Build something real using Overlapping" + ] + }, + { + "id": "cp-gen-058", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #5", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 7640 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #5.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #5", + "Apply Full-Stack Engineer Project #5 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #5", + "Build something real using Full-Stack Engineer Project #5" + ] + }, + { + "id": "cp-gen-059", + "roadmap_id": "rm-generated", + "label": "Hierarchical", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 7770 + }, + "description": "Learn the key concepts of Hierarchical.", + "learning_goals": [ + "Understand the core principles of Hierarchical", + "Apply Hierarchical in practical scenarios", + "Explore advanced patterns in Hierarchical", + "Build something real using Hierarchical" + ] + }, + { + "id": "cp-gen-060", + "roadmap_id": "rm-generated", + "label": "Probabilistic", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 7900 + }, + "description": "Learn the key concepts of Probabilistic.", + "learning_goals": [ + "Understand the core principles of Probabilistic", + "Apply Probabilistic in practical scenarios", + "Explore advanced patterns in Probabilistic", + "Build something real using Probabilistic" + ] + }, + { + "id": "cp-gen-061", + "roadmap_id": "rm-generated", + "label": "Precision", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 8030 + }, + "description": "Learn the key concepts of Precision.", + "learning_goals": [ + "Understand the core principles of Precision", + "Apply Precision in practical scenarios", + "Explore advanced patterns in Precision", + "Build something real using Precision" + ] + }, + { + "id": "cp-gen-062", + "roadmap_id": "rm-generated", + "label": "Precision Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 8160 + }, + "description": "Learn the key concepts of Precision Quiz.", + "learning_goals": [ + "Understand the core principles of Precision Quiz", + "Apply Precision Quiz in practical scenarios", + "Explore advanced patterns in Precision Quiz", + "Build something real using Precision Quiz" + ] + }, + { + "id": "cp-gen-063", + "roadmap_id": "rm-generated", + "label": "What is Model Evaluation?", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 8290 + }, + "description": "Learn the key concepts of What is Model Evaluation?.", + "learning_goals": [ + "Understand the core principles of What is Model Evaluation?", + "Apply What is Model Evaluation? in practical scenarios", + "Explore advanced patterns in What is Model Evaluation?", + "Build something real using What is Model Evaluation?" + ] + }, + { + "id": "cp-gen-064", + "roadmap_id": "rm-generated", + "label": "Recall", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 8420 + }, + "description": "Learn the key concepts of Recall.", + "learning_goals": [ + "Understand the core principles of Recall", + "Apply Recall in practical scenarios", + "Explore advanced patterns in Recall", + "Build something real using Recall" + ] + }, + { + "id": "cp-gen-065", + "roadmap_id": "rm-generated", + "label": "Why is it important?", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 8550 + }, + "description": "Learn the key concepts of Why is it important?.", + "learning_goals": [ + "Understand the core principles of Why is it important?", + "Apply Why is it important? in practical scenarios", + "Explore advanced patterns in Why is it important?", + "Build something real using Why is it important?" + ] + }, + { + "id": "cp-gen-066", + "roadmap_id": "rm-generated", + "label": "Why is it important? Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 8680 + }, + "description": "Learn the key concepts of Why is it important? Quiz.", + "learning_goals": [ + "Understand the core principles of Why is it important? Quiz", + "Apply Why is it important? Quiz in practical scenarios", + "Explore advanced patterns in Why is it important? Quiz", + "Build something real using Why is it important? Quiz" + ] + }, + { + "id": "cp-gen-067", + "roadmap_id": "rm-generated", + "label": "Log Loss", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 8810 + }, + "description": "Learn the key concepts of Log Loss.", + "learning_goals": [ + "Understand the core principles of Log Loss", + "Apply Log Loss in practical scenarios", + "Explore advanced patterns in Log Loss", + "Build something real using Log Loss" + ] + }, + { + "id": "cp-gen-068", + "roadmap_id": "rm-generated", + "label": "Metrics to Evaluate", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 8940 + }, + "description": "Learn the key concepts of Metrics to Evaluate.", + "learning_goals": [ + "Understand the core principles of Metrics to Evaluate", + "Apply Metrics to Evaluate in practical scenarios", + "Explore advanced patterns in Metrics to Evaluate", + "Build something real using Metrics to Evaluate" + ] + }, + { + "id": "cp-gen-069", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #6", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 9070 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #6.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #6", + "Apply Full-Stack Engineer Project #6 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #6", + "Build something real using Full-Stack Engineer Project #6" + ] + }, + { + "id": "cp-gen-070", + "roadmap_id": "rm-generated", + "label": "Accuracy", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 9200 + }, + "description": "Learn the key concepts of Accuracy.", + "learning_goals": [ + "Understand the core principles of Accuracy", + "Apply Accuracy in practical scenarios", + "Explore advanced patterns in Accuracy", + "Build something real using Accuracy" + ] + }, + { + "id": "cp-gen-071", + "roadmap_id": "rm-generated", + "label": "F1-Score", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 9330 + }, + "description": "Learn the key concepts of F1-Score.", + "learning_goals": [ + "Understand the core principles of F1-Score", + "Apply F1-Score in practical scenarios", + "Explore advanced patterns in F1-Score", + "Build something real using F1-Score" + ] + }, + { + "id": "cp-gen-072", + "roadmap_id": "rm-generated", + "label": "ROC-AUC", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 9460 + }, + "description": "Learn the key concepts of ROC-AUC.", + "learning_goals": [ + "Understand the core principles of ROC-AUC", + "Apply ROC-AUC in practical scenarios", + "Explore advanced patterns in ROC-AUC", + "Build something real using ROC-AUC" + ] + }, + { + "id": "cp-gen-073", + "roadmap_id": "rm-generated", + "label": "Confusion Matrix", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 9590 + }, + "description": "Learn the key concepts of Confusion Matrix.", + "learning_goals": [ + "Understand the core principles of Confusion Matrix", + "Apply Confusion Matrix in practical scenarios", + "Explore advanced patterns in Confusion Matrix", + "Build something real using Confusion Matrix" + ] + }, + { + "id": "cp-gen-074", + "roadmap_id": "rm-generated", + "label": "Confusion Matrix Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 9720 + }, + "description": "Learn the key concepts of Confusion Matrix Quiz.", + "learning_goals": [ + "Understand the core principles of Confusion Matrix Quiz", + "Apply Confusion Matrix Quiz in practical scenarios", + "Explore advanced patterns in Confusion Matrix Quiz", + "Build something real using Confusion Matrix Quiz" + ] + }, + { + "id": "cp-gen-075", + "roadmap_id": "rm-generated", + "label": "Validation Techniques", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 9850 + }, + "description": "Learn the key concepts of Validation Techniques.", + "learning_goals": [ + "Understand the core principles of Validation Techniques", + "Apply Validation Techniques in practical scenarios", + "Explore advanced patterns in Validation Techniques", + "Build something real using Validation Techniques" + ] + }, + { + "id": "cp-gen-076", + "roadmap_id": "rm-generated", + "label": "K-Fold Cross Validation", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 9980 + }, + "description": "Learn the key concepts of K-Fold Cross Validation.", + "learning_goals": [ + "Understand the core principles of K-Fold Cross Validation", + "Apply K-Fold Cross Validation in practical scenarios", + "Explore advanced patterns in K-Fold Cross Validation", + "Build something real using K-Fold Cross Validation" + ] + }, + { + "id": "cp-gen-077", + "roadmap_id": "rm-generated", + "label": "K-Fold Cross Validation Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 10110 + }, + "description": "Learn the key concepts of K-Fold Cross Validation Quiz.", + "learning_goals": [ + "Understand the core principles of K-Fold Cross Validation Quiz", + "Apply K-Fold Cross Validation Quiz in practical scenarios", + "Explore advanced patterns in K-Fold Cross Validation Quiz", + "Build something real using K-Fold Cross Validation Quiz" + ] + }, + { + "id": "cp-gen-078", + "roadmap_id": "rm-generated", + "label": "LOOCV", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 10240 + }, + "description": "Learn the key concepts of LOOCV.", + "learning_goals": [ + "Understand the core principles of LOOCV", + "Apply LOOCV in practical scenarios", + "Explore advanced patterns in LOOCV", + "Build something real using LOOCV" + ] + }, + { + "id": "cp-gen-079", + "roadmap_id": "rm-generated", + "label": "Neural Network (NN) Basics", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 10370 + }, + "description": "Learn the key concepts of Neural Network (NN) Basics.", + "learning_goals": [ + "Understand the core principles of Neural Network (NN) Basics", + "Apply Neural Network (NN) Basics in practical scenarios", + "Explore advanced patterns in Neural Network (NN) Basics", + "Build something real using Neural Network (NN) Basics" + ] + }, + { + "id": "cp-gen-080", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #7", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 10500 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #7.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #7", + "Apply Full-Stack Engineer Project #7 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #7", + "Build something real using Full-Stack Engineer Project #7" + ] + }, + { + "id": "cp-gen-081", + "roadmap_id": "rm-generated", + "label": "Deep Learning Libraries", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 10630 + }, + "description": "Learn the key concepts of Deep Learning Libraries.", + "learning_goals": [ + "Understand the core principles of Deep Learning Libraries", + "Apply Deep Learning Libraries in practical scenarios", + "Explore advanced patterns in Deep Learning Libraries", + "Build something real using Deep Learning Libraries" + ] + }, + { + "id": "cp-gen-082", + "roadmap_id": "rm-generated", + "label": "Deep Learning Architectures", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 10760 + }, + "description": "Learn the key concepts of Deep Learning Architectures.", + "learning_goals": [ + "Understand the core principles of Deep Learning Architectures", + "Apply Deep Learning Architectures in practical scenarios", + "Explore advanced patterns in Deep Learning Architectures", + "Build something real using Deep Learning Architectures" + ] + }, + { + "id": "cp-gen-083", + "roadmap_id": "rm-generated", + "label": "Perceptron, Multi-layer Perceptrons", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 10890 + }, + "description": "Learn the key concepts of Perceptron, Multi-layer Perceptrons.", + "learning_goals": [ + "Understand the core principles of Perceptron, Multi-layer Perceptrons", + "Apply Perceptron, Multi-layer Perceptrons in practical scenarios", + "Explore advanced patterns in Perceptron, Multi-layer Perceptrons", + "Build something real using Perceptron, Multi-layer Perceptrons" + ] + }, + { + "id": "cp-gen-084", + "roadmap_id": "rm-generated", + "label": "TensorFlow", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 11020 + }, + "description": "Learn the key concepts of TensorFlow.", + "learning_goals": [ + "Understand the core principles of TensorFlow", + "Apply TensorFlow in practical scenarios", + "Explore advanced patterns in TensorFlow", + "Build something real using TensorFlow" + ] + }, + { + "id": "cp-gen-085", + "roadmap_id": "rm-generated", + "label": "TensorFlow Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 11150 + }, + "description": "Learn the key concepts of TensorFlow Quiz.", + "learning_goals": [ + "Understand the core principles of TensorFlow Quiz", + "Apply TensorFlow Quiz in practical scenarios", + "Explore advanced patterns in TensorFlow Quiz", + "Build something real using TensorFlow Quiz" + ] + }, + { + "id": "cp-gen-086", + "roadmap_id": "rm-generated", + "label": "Keras", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 11280 + }, + "description": "Learn the key concepts of Keras.", + "learning_goals": [ + "Understand the core principles of Keras", + "Apply Keras in practical scenarios", + "Explore advanced patterns in Keras", + "Build something real using Keras" + ] + }, + { + "id": "cp-gen-087", + "roadmap_id": "rm-generated", + "label": "Forward propagation", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 11410 + }, + "description": "Learn the key concepts of Forward propagation.", + "learning_goals": [ + "Understand the core principles of Forward propagation", + "Apply Forward propagation in practical scenarios", + "Explore advanced patterns in Forward propagation", + "Build something real using Forward propagation" + ] + }, + { + "id": "cp-gen-088", + "roadmap_id": "rm-generated", + "label": "Cloud Skills and Knowledge", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 11540 + }, + "description": "Learn the key concepts of Cloud Skills and Knowledge.", + "learning_goals": [ + "Understand the core principles of Cloud Skills and Knowledge", + "Apply Cloud Skills and Knowledge in practical scenarios", + "Explore advanced patterns in Cloud Skills and Knowledge", + "Build something real using Cloud Skills and Knowledge" + ] + }, + { + "id": "cp-gen-089", + "roadmap_id": "rm-generated", + "label": "Cloud Skills and Knowledge Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 11670 + }, + "description": "Learn the key concepts of Cloud Skills and Knowledge Quiz.", + "learning_goals": [ + "Understand the core principles of Cloud Skills and Knowledge Quiz", + "Apply Cloud Skills and Knowledge Quiz in practical scenarios", + "Explore advanced patterns in Cloud Skills and Knowledge Quiz", + "Build something real using Cloud Skills and Knowledge Quiz" + ] + }, + { + "id": "cp-gen-090", + "roadmap_id": "rm-generated", + "label": "PyTorch", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 11800 + }, + "description": "Learn the key concepts of PyTorch.", + "learning_goals": [ + "Understand the core principles of PyTorch", + "Apply PyTorch in practical scenarios", + "Explore advanced patterns in PyTorch", + "Build something real using PyTorch" + ] + }, + { + "id": "cp-gen-091", + "roadmap_id": "rm-generated", + "label": "Back Propagation", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 11930 + }, + "description": "Learn the key concepts of Back Propagation.", + "learning_goals": [ + "Understand the core principles of Back Propagation", + "Apply Back Propagation in practical scenarios", + "Explore advanced patterns in Back Propagation", + "Build something real using Back Propagation" + ] + }, + { + "id": "cp-gen-092", + "roadmap_id": "rm-generated", + "label": "Full-Stack Engineer Project #8", + "kind": "project", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 12060 + }, + "description": "Learn the key concepts of Full-Stack Engineer Project #8.", + "learning_goals": [ + "Understand the core principles of Full-Stack Engineer Project #8", + "Apply Full-Stack Engineer Project #8 in practical scenarios", + "Explore advanced patterns in Full-Stack Engineer Project #8", + "Build something real using Full-Stack Engineer Project #8" + ] + }, + { + "id": "cp-gen-093", + "roadmap_id": "rm-generated", + "label": "Convolutional Neural Network", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 12190 + }, + "description": "Learn the key concepts of Convolutional Neural Network.", + "learning_goals": [ + "Understand the core principles of Convolutional Neural Network", + "Apply Convolutional Neural Network in practical scenarios", + "Explore advanced patterns in Convolutional Neural Network", + "Build something real using Convolutional Neural Network" + ] + }, + { + "id": "cp-gen-094", + "roadmap_id": "rm-generated", + "label": "Convolution", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 12320 + }, + "description": "Learn the key concepts of Convolution.", + "learning_goals": [ + "Understand the core principles of Convolution", + "Apply Convolution in practical scenarios", + "Explore advanced patterns in Convolution", + "Build something real using Convolution" + ] + }, + { + "id": "cp-gen-095", + "roadmap_id": "rm-generated", + "label": "Pooling", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 12450 + }, + "description": "Learn the key concepts of Pooling.", + "learning_goals": [ + "Understand the core principles of Pooling", + "Apply Pooling in practical scenarios", + "Explore advanced patterns in Pooling", + "Build something real using Pooling" + ] + }, + { + "id": "cp-gen-096", + "roadmap_id": "rm-generated", + "label": "Activation Functions", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 12580 + }, + "description": "Learn the key concepts of Activation Functions.", + "learning_goals": [ + "Understand the core principles of Activation Functions", + "Apply Activation Functions in practical scenarios", + "Explore advanced patterns in Activation Functions", + "Build something real using Activation Functions" + ] + }, + { + "id": "cp-gen-097", + "roadmap_id": "rm-generated", + "label": "Activation Functions Quiz", + "kind": "quiz", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 12710 + }, + "description": "Learn the key concepts of Activation Functions Quiz.", + "learning_goals": [ + "Understand the core principles of Activation Functions Quiz", + "Apply Activation Functions Quiz in practical scenarios", + "Explore advanced patterns in Activation Functions Quiz", + "Build something real using Activation Functions Quiz" + ] + }, + { + "id": "cp-gen-098", + "roadmap_id": "rm-generated", + "label": "Padding", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 300, + "y": 12840 + }, + "description": "Learn the key concepts of Padding.", + "learning_goals": [ + "Understand the core principles of Padding", + "Apply Padding in practical scenarios", + "Explore advanced patterns in Padding", + "Build something real using Padding" + ] + }, + { + "id": "cp-gen-099", + "roadmap_id": "rm-generated", + "label": "Strides", + "kind": "lesson", + "progress": 0, + "locked": true, + "position": { + "x": 500, + "y": 12970 + }, + "description": "Learn the key concepts of Strides.", + "learning_goals": [ + "Understand the core principles of Strides", + "Apply Strides in practical scenarios", + "Explore advanced patterns in Strides", + "Build something real using Strides" + ] + } + ], + "tasks": [ + { + "id": "t-001", + "checkpoint_id": "cp-001", + "user_id": "u-001", + "title": "HTML Elements", + "tag": "HTML", + "status": "not_started", + "description": "Learn the core HTML elements and how to structure a semantic web page." + }, + { + "id": "t-002", + "checkpoint_id": "cp-002", + "user_id": "u-001", + "title": "CSS Styling", + "tag": "CSS", + "status": "not_started", + "description": "Apply styles using selectors, the box model, and Flexbox/Grid layouts." + }, + { + "id": "t-003", + "checkpoint_id": "cp-004", + "user_id": "u-001", + "title": "Javascript Components", + "tag": "JS", + "status": "not_started", + "description": "Build interactive UI components using vanilla JavaScript and DOM events." + }, + { + "id": "t-004", + "checkpoint_id": null, + "user_id": "u-001", + "title": "Python Fundamentals", + "tag": "Python", + "status": "not_started", + "description": "Explore Python syntax, data structures, and scripting basics." + } + ], + "user_task_progress": [ + { + "id": "utp-001", + "user_id": "u-001", + "task_id": "t-001", + "status": "not_started", + "started_at": null, + "completed_at": null + }, + { + "id": "utp-002", + "user_id": "u-001", + "task_id": "t-002", + "status": "not_started", + "started_at": null, + "completed_at": null + }, + { + "id": "utp-003", + "user_id": "u-001", + "task_id": "t-003", + "status": "not_started", + "started_at": null, + "completed_at": null + }, + { + "id": "utp-004", + "user_id": "u-001", + "task_id": "t-004", + "status": "not_started", + "started_at": null, + "completed_at": null + } + ], + "user_gamification": [ + { + "id": "ug-001", + "user_id": "u-001", + "xp_total": 2455, + "tasks_completed": 13, + "leaderboard_rank": 2, + "current_streak": 1, + "longest_streak": 31, + "updated_at": "2026-03-29T12:00:00Z" + } + ], + "achievements": [ + { + "id": "ach-001", + "title": "Zari's Movie Binge", + "description": "Complete 5 lessons in a single day", + "icon": "film", + "xp_reward": 100 + }, + { + "id": "ach-002", + "title": "Eddy's Wood Carving Craft", + "description": "Finish a project checkpoint from start to finish", + "icon": "hammer", + "xp_reward": 200 + }, + { + "id": "ach-003", + "title": "Duo's Chess Match", + "description": "Maintain a 7-day learning streak", + "icon": "chess", + "xp_reward": 150 + } + ], + "user_achievements": [ + { + "id": "ua-001", + "user_id": "u-001", + "achievement_id": "ach-001", + "earned_at": "2026-02-10T09:00:00Z" + }, + { + "id": "ua-002", + "user_id": "u-001", + "achievement_id": "ach-002", + "earned_at": "2026-03-01T14:30:00Z" + }, + { + "id": "ua-003", + "user_id": "u-001", + "achievement_id": "ach-003", + "earned_at": "2026-03-15T08:00:00Z" + } + ], + "leaderboard": [ + { + "rank": 1, + "name": "Tom Wilson", + "subtitle": "Master Level", + "streak": 28, + "is_you": false, + "avatar": "TW", + "avatar_bg": "#6366f1" + }, + { + "rank": 2, + "name": "Alex Morgan", + "subtitle": "Advanced Level", + "streak": 1, + "is_you": true, + "avatar": "AM", + "avatar_bg": "#10b981" + }, + { + "rank": 3, + "name": "Sarah Chen", + "subtitle": "Intermediate Level", + "streak": 18, + "is_you": false, + "avatar": "SC", + "avatar_bg": "#f59e0b" + }, + { + "rank": 4, + "name": "Marcus Johnson", + "subtitle": "Intermediate Level", + "streak": 15, + "is_you": false, + "avatar": "MJ", + "avatar_bg": "#ef4444" + } + ], + "roadmap_edges": [ + { + "id": "e-cp001-cp002", + "roadmap_id": "rm-001", + "source": "cp-001", + "target": "cp-002" + }, + { + "id": "e-cp002-cp003", + "roadmap_id": "rm-001", + "source": "cp-002", + "target": "cp-003" + }, + { + "id": "e-cp003-cp004", + "roadmap_id": "rm-001", + "source": "cp-003", + "target": "cp-004" + }, + { + "id": "e-cp003-cp005", + "roadmap_id": "rm-001", + "source": "cp-003", + "target": "cp-005" + }, + { + "id": "e-cp004-cp006", + "roadmap_id": "rm-001", + "source": "cp-004", + "target": "cp-006" + }, + { + "id": "e-cp005-cp006", + "roadmap_id": "rm-001", + "source": "cp-005", + "target": "cp-006" + }, + { + "id": "e-cp006-cp007", + "roadmap_id": "rm-001", + "source": "cp-006", + "target": "cp-007" + }, + { + "id": "e-cp007-cp008", + "roadmap_id": "rm-001", + "source": "cp-007", + "target": "cp-008" + }, + { + "id": "edge-gen-000", + "roadmap_id": "rm-generated", + "source": "cp-gen-000", + "target": "cp-gen-001" + }, + { + "id": "edge-gen-001", + "roadmap_id": "rm-generated", + "source": "cp-gen-001", + "target": "cp-gen-002" + }, + { + "id": "edge-gen-002", + "roadmap_id": "rm-generated", + "source": "cp-gen-002", + "target": "cp-gen-003" + }, + { + "id": "edge-gen-003", + "roadmap_id": "rm-generated", + "source": "cp-gen-003", + "target": "cp-gen-007" + }, + { + "id": "edge-gen-004", + "roadmap_id": "rm-generated", + "source": "cp-gen-002", + "target": "cp-gen-004" + }, + { + "id": "edge-gen-005", + "roadmap_id": "rm-generated", + "source": "cp-gen-004", + "target": "cp-gen-005" + }, + { + "id": "edge-gen-006", + "roadmap_id": "rm-generated", + "source": "cp-gen-005", + "target": "cp-gen-006" + }, + { + "id": "edge-gen-007", + "roadmap_id": "rm-generated", + "source": "cp-gen-006", + "target": "cp-gen-007" + }, + { + "id": "edge-gen-008", + "roadmap_id": "rm-generated", + "source": "cp-gen-007", + "target": "cp-gen-008" + }, + { + "id": "edge-gen-009", + "roadmap_id": "rm-generated", + "source": "cp-gen-008", + "target": "cp-gen-009" + }, + { + "id": "edge-gen-010", + "roadmap_id": "rm-generated", + "source": "cp-gen-009", + "target": "cp-gen-011" + }, + { + "id": "edge-gen-011", + "roadmap_id": "rm-generated", + "source": "cp-gen-007", + "target": "cp-gen-010" + }, + { + "id": "edge-gen-012", + "roadmap_id": "rm-generated", + "source": "cp-gen-010", + "target": "cp-gen-011" + }, + { + "id": "edge-gen-013", + "roadmap_id": "rm-generated", + "source": "cp-gen-011", + "target": "cp-gen-012" + }, + { + "id": "edge-gen-014", + "roadmap_id": "rm-generated", + "source": "cp-gen-012", + "target": "cp-gen-014" + }, + { + "id": "edge-gen-015", + "roadmap_id": "rm-generated", + "source": "cp-gen-011", + "target": "cp-gen-013" + }, + { + "id": "edge-gen-016", + "roadmap_id": "rm-generated", + "source": "cp-gen-013", + "target": "cp-gen-014" + }, + { + "id": "edge-gen-017", + "roadmap_id": "rm-generated", + "source": "cp-gen-014", + "target": "cp-gen-015" + }, + { + "id": "edge-gen-018", + "roadmap_id": "rm-generated", + "source": "cp-gen-015", + "target": "cp-gen-019" + }, + { + "id": "edge-gen-019", + "roadmap_id": "rm-generated", + "source": "cp-gen-014", + "target": "cp-gen-016" + }, + { + "id": "edge-gen-020", + "roadmap_id": "rm-generated", + "source": "cp-gen-016", + "target": "cp-gen-019" + }, + { + "id": "edge-gen-021", + "roadmap_id": "rm-generated", + "source": "cp-gen-014", + "target": "cp-gen-017" + }, + { + "id": "edge-gen-022", + "roadmap_id": "rm-generated", + "source": "cp-gen-017", + "target": "cp-gen-018" + }, + { + "id": "edge-gen-023", + "roadmap_id": "rm-generated", + "source": "cp-gen-018", + "target": "cp-gen-019" + }, + { + "id": "edge-gen-024", + "roadmap_id": "rm-generated", + "source": "cp-gen-019", + "target": "cp-gen-020" + }, + { + "id": "edge-gen-025", + "roadmap_id": "rm-generated", + "source": "cp-gen-020", + "target": "cp-gen-023" + }, + { + "id": "edge-gen-026", + "roadmap_id": "rm-generated", + "source": "cp-gen-019", + "target": "cp-gen-021" + }, + { + "id": "edge-gen-027", + "roadmap_id": "rm-generated", + "source": "cp-gen-021", + "target": "cp-gen-022" + }, + { + "id": "edge-gen-028", + "roadmap_id": "rm-generated", + "source": "cp-gen-022", + "target": "cp-gen-023" + }, + { + "id": "edge-gen-029", + "roadmap_id": "rm-generated", + "source": "cp-gen-023", + "target": "cp-gen-024" + }, + { + "id": "edge-gen-030", + "roadmap_id": "rm-generated", + "source": "cp-gen-024", + "target": "cp-gen-025" + }, + { + "id": "edge-gen-031", + "roadmap_id": "rm-generated", + "source": "cp-gen-025", + "target": "cp-gen-027" + }, + { + "id": "edge-gen-032", + "roadmap_id": "rm-generated", + "source": "cp-gen-023", + "target": "cp-gen-026" + }, + { + "id": "edge-gen-033", + "roadmap_id": "rm-generated", + "source": "cp-gen-026", + "target": "cp-gen-027" + }, + { + "id": "edge-gen-034", + "roadmap_id": "rm-generated", + "source": "cp-gen-027", + "target": "cp-gen-028" + }, + { + "id": "edge-gen-035", + "roadmap_id": "rm-generated", + "source": "cp-gen-028", + "target": "cp-gen-030" + }, + { + "id": "edge-gen-036", + "roadmap_id": "rm-generated", + "source": "cp-gen-027", + "target": "cp-gen-029" + }, + { + "id": "edge-gen-037", + "roadmap_id": "rm-generated", + "source": "cp-gen-029", + "target": "cp-gen-030" + }, + { + "id": "edge-gen-038", + "roadmap_id": "rm-generated", + "source": "cp-gen-030", + "target": "cp-gen-031" + }, + { + "id": "edge-gen-039", + "roadmap_id": "rm-generated", + "source": "cp-gen-031", + "target": "cp-gen-032" + }, + { + "id": "edge-gen-040", + "roadmap_id": "rm-generated", + "source": "cp-gen-032", + "target": "cp-gen-035" + }, + { + "id": "edge-gen-041", + "roadmap_id": "rm-generated", + "source": "cp-gen-030", + "target": "cp-gen-033" + }, + { + "id": "edge-gen-042", + "roadmap_id": "rm-generated", + "source": "cp-gen-033", + "target": "cp-gen-034" + }, + { + "id": "edge-gen-043", + "roadmap_id": "rm-generated", + "source": "cp-gen-034", + "target": "cp-gen-035" + }, + { + "id": "edge-gen-044", + "roadmap_id": "rm-generated", + "source": "cp-gen-035", + "target": "cp-gen-036" + }, + { + "id": "edge-gen-045", + "roadmap_id": "rm-generated", + "source": "cp-gen-036", + "target": "cp-gen-038" + }, + { + "id": "edge-gen-046", + "roadmap_id": "rm-generated", + "source": "cp-gen-035", + "target": "cp-gen-037" + }, + { + "id": "edge-gen-047", + "roadmap_id": "rm-generated", + "source": "cp-gen-037", + "target": "cp-gen-038" + }, + { + "id": "edge-gen-048", + "roadmap_id": "rm-generated", + "source": "cp-gen-038", + "target": "cp-gen-039" + }, + { + "id": "edge-gen-049", + "roadmap_id": "rm-generated", + "source": "cp-gen-039", + "target": "cp-gen-040" + }, + { + "id": "edge-gen-050", + "roadmap_id": "rm-generated", + "source": "cp-gen-040", + "target": "cp-gen-041" + }, + { + "id": "edge-gen-051", + "roadmap_id": "rm-generated", + "source": "cp-gen-041", + "target": "cp-gen-042" + }, + { + "id": "edge-gen-052", + "roadmap_id": "rm-generated", + "source": "cp-gen-042", + "target": "cp-gen-043" + }, + { + "id": "edge-gen-053", + "roadmap_id": "rm-generated", + "source": "cp-gen-043", + "target": "cp-gen-044" + }, + { + "id": "edge-gen-054", + "roadmap_id": "rm-generated", + "source": "cp-gen-044", + "target": "cp-gen-045" + }, + { + "id": "edge-gen-055", + "roadmap_id": "rm-generated", + "source": "cp-gen-045", + "target": "cp-gen-046" + }, + { + "id": "edge-gen-056", + "roadmap_id": "rm-generated", + "source": "cp-gen-046", + "target": "cp-gen-047" + }, + { + "id": "edge-gen-057", + "roadmap_id": "rm-generated", + "source": "cp-gen-047", + "target": "cp-gen-050" + }, + { + "id": "edge-gen-058", + "roadmap_id": "rm-generated", + "source": "cp-gen-046", + "target": "cp-gen-048" + }, + { + "id": "edge-gen-059", + "roadmap_id": "rm-generated", + "source": "cp-gen-048", + "target": "cp-gen-050" + }, + { + "id": "edge-gen-060", + "roadmap_id": "rm-generated", + "source": "cp-gen-046", + "target": "cp-gen-049" + }, + { + "id": "edge-gen-061", + "roadmap_id": "rm-generated", + "source": "cp-gen-049", + "target": "cp-gen-050" + }, + { + "id": "edge-gen-062", + "roadmap_id": "rm-generated", + "source": "cp-gen-050", + "target": "cp-gen-051" + }, + { + "id": "edge-gen-063", + "roadmap_id": "rm-generated", + "source": "cp-gen-051", + "target": "cp-gen-053" + }, + { + "id": "edge-gen-064", + "roadmap_id": "rm-generated", + "source": "cp-gen-050", + "target": "cp-gen-052" + }, + { + "id": "edge-gen-065", + "roadmap_id": "rm-generated", + "source": "cp-gen-052", + "target": "cp-gen-053" + }, + { + "id": "edge-gen-066", + "roadmap_id": "rm-generated", + "source": "cp-gen-053", + "target": "cp-gen-054" + }, + { + "id": "edge-gen-067", + "roadmap_id": "rm-generated", + "source": "cp-gen-054", + "target": "cp-gen-055" + }, + { + "id": "edge-gen-068", + "roadmap_id": "rm-generated", + "source": "cp-gen-055", + "target": "cp-gen-058" + }, + { + "id": "edge-gen-069", + "roadmap_id": "rm-generated", + "source": "cp-gen-053", + "target": "cp-gen-056" + }, + { + "id": "edge-gen-070", + "roadmap_id": "rm-generated", + "source": "cp-gen-056", + "target": "cp-gen-057" + }, + { + "id": "edge-gen-071", + "roadmap_id": "rm-generated", + "source": "cp-gen-057", + "target": "cp-gen-058" + }, + { + "id": "edge-gen-072", + "roadmap_id": "rm-generated", + "source": "cp-gen-058", + "target": "cp-gen-059" + }, + { + "id": "edge-gen-073", + "roadmap_id": "rm-generated", + "source": "cp-gen-059", + "target": "cp-gen-060" + }, + { + "id": "edge-gen-074", + "roadmap_id": "rm-generated", + "source": "cp-gen-060", + "target": "cp-gen-061" + }, + { + "id": "edge-gen-075", + "roadmap_id": "rm-generated", + "source": "cp-gen-061", + "target": "cp-gen-062" + }, + { + "id": "edge-gen-076", + "roadmap_id": "rm-generated", + "source": "cp-gen-062", + "target": "cp-gen-063" + }, + { + "id": "edge-gen-077", + "roadmap_id": "rm-generated", + "source": "cp-gen-063", + "target": "cp-gen-066" + }, + { + "id": "edge-gen-078", + "roadmap_id": "rm-generated", + "source": "cp-gen-062", + "target": "cp-gen-064" + }, + { + "id": "edge-gen-079", + "roadmap_id": "rm-generated", + "source": "cp-gen-064", + "target": "cp-gen-066" + }, + { + "id": "edge-gen-080", + "roadmap_id": "rm-generated", + "source": "cp-gen-062", + "target": "cp-gen-065" + }, + { + "id": "edge-gen-081", + "roadmap_id": "rm-generated", + "source": "cp-gen-065", + "target": "cp-gen-066" + }, + { + "id": "edge-gen-082", + "roadmap_id": "rm-generated", + "source": "cp-gen-066", + "target": "cp-gen-067" + }, + { + "id": "edge-gen-083", + "roadmap_id": "rm-generated", + "source": "cp-gen-067", + "target": "cp-gen-069" + }, + { + "id": "edge-gen-084", + "roadmap_id": "rm-generated", + "source": "cp-gen-066", + "target": "cp-gen-068" + }, + { + "id": "edge-gen-085", + "roadmap_id": "rm-generated", + "source": "cp-gen-068", + "target": "cp-gen-069" + }, + { + "id": "edge-gen-086", + "roadmap_id": "rm-generated", + "source": "cp-gen-069", + "target": "cp-gen-070" + }, + { + "id": "edge-gen-087", + "roadmap_id": "rm-generated", + "source": "cp-gen-070", + "target": "cp-gen-071" + }, + { + "id": "edge-gen-088", + "roadmap_id": "rm-generated", + "source": "cp-gen-071", + "target": "cp-gen-074" + }, + { + "id": "edge-gen-089", + "roadmap_id": "rm-generated", + "source": "cp-gen-069", + "target": "cp-gen-072" + }, + { + "id": "edge-gen-090", + "roadmap_id": "rm-generated", + "source": "cp-gen-072", + "target": "cp-gen-074" + }, + { + "id": "edge-gen-091", + "roadmap_id": "rm-generated", + "source": "cp-gen-069", + "target": "cp-gen-073" + }, + { + "id": "edge-gen-092", + "roadmap_id": "rm-generated", + "source": "cp-gen-073", + "target": "cp-gen-074" + }, + { + "id": "edge-gen-093", + "roadmap_id": "rm-generated", + "source": "cp-gen-074", + "target": "cp-gen-075" + }, + { + "id": "edge-gen-094", + "roadmap_id": "rm-generated", + "source": "cp-gen-075", + "target": "cp-gen-077" + }, + { + "id": "edge-gen-095", + "roadmap_id": "rm-generated", + "source": "cp-gen-074", + "target": "cp-gen-076" + }, + { + "id": "edge-gen-096", + "roadmap_id": "rm-generated", + "source": "cp-gen-076", + "target": "cp-gen-077" + }, + { + "id": "edge-gen-097", + "roadmap_id": "rm-generated", + "source": "cp-gen-077", + "target": "cp-gen-078" + }, + { + "id": "edge-gen-098", + "roadmap_id": "rm-generated", + "source": "cp-gen-078", + "target": "cp-gen-079" + }, + { + "id": "edge-gen-099", + "roadmap_id": "rm-generated", + "source": "cp-gen-079", + "target": "cp-gen-080" + }, + { + "id": "edge-gen-100", + "roadmap_id": "rm-generated", + "source": "cp-gen-080", + "target": "cp-gen-081" + }, + { + "id": "edge-gen-101", + "roadmap_id": "rm-generated", + "source": "cp-gen-081", + "target": "cp-gen-082" + }, + { + "id": "edge-gen-102", + "roadmap_id": "rm-generated", + "source": "cp-gen-082", + "target": "cp-gen-083" + }, + { + "id": "edge-gen-103", + "roadmap_id": "rm-generated", + "source": "cp-gen-083", + "target": "cp-gen-085" + }, + { + "id": "edge-gen-104", + "roadmap_id": "rm-generated", + "source": "cp-gen-080", + "target": "cp-gen-084" + }, + { + "id": "edge-gen-105", + "roadmap_id": "rm-generated", + "source": "cp-gen-084", + "target": "cp-gen-085" + }, + { + "id": "edge-gen-106", + "roadmap_id": "rm-generated", + "source": "cp-gen-085", + "target": "cp-gen-086" + }, + { + "id": "edge-gen-107", + "roadmap_id": "rm-generated", + "source": "cp-gen-086", + "target": "cp-gen-087" + }, + { + "id": "edge-gen-108", + "roadmap_id": "rm-generated", + "source": "cp-gen-087", + "target": "cp-gen-089" + }, + { + "id": "edge-gen-109", + "roadmap_id": "rm-generated", + "source": "cp-gen-085", + "target": "cp-gen-088" + }, + { + "id": "edge-gen-110", + "roadmap_id": "rm-generated", + "source": "cp-gen-088", + "target": "cp-gen-089" + }, + { + "id": "edge-gen-111", + "roadmap_id": "rm-generated", + "source": "cp-gen-089", + "target": "cp-gen-090" + }, + { + "id": "edge-gen-112", + "roadmap_id": "rm-generated", + "source": "cp-gen-090", + "target": "cp-gen-092" + }, + { + "id": "edge-gen-113", + "roadmap_id": "rm-generated", + "source": "cp-gen-089", + "target": "cp-gen-091" + }, + { + "id": "edge-gen-114", + "roadmap_id": "rm-generated", + "source": "cp-gen-091", + "target": "cp-gen-092" + }, + { + "id": "edge-gen-115", + "roadmap_id": "rm-generated", + "source": "cp-gen-092", + "target": "cp-gen-093" + }, + { + "id": "edge-gen-116", + "roadmap_id": "rm-generated", + "source": "cp-gen-093", + "target": "cp-gen-094" + }, + { + "id": "edge-gen-117", + "roadmap_id": "rm-generated", + "source": "cp-gen-094", + "target": "cp-gen-097" + }, + { + "id": "edge-gen-118", + "roadmap_id": "rm-generated", + "source": "cp-gen-092", + "target": "cp-gen-095" + }, + { + "id": "edge-gen-119", + "roadmap_id": "rm-generated", + "source": "cp-gen-095", + "target": "cp-gen-097" + }, + { + "id": "edge-gen-120", + "roadmap_id": "rm-generated", + "source": "cp-gen-092", + "target": "cp-gen-096" + }, + { + "id": "edge-gen-121", + "roadmap_id": "rm-generated", + "source": "cp-gen-096", + "target": "cp-gen-097" + }, + { + "id": "edge-gen-122", + "roadmap_id": "rm-generated", + "source": "cp-gen-097", + "target": "cp-gen-098" + }, + { + "id": "edge-gen-123", + "roadmap_id": "rm-generated", + "source": "cp-gen-098", + "target": "cp-gen-099" + } + ], + "quiz_questions": { + "cp-003": [ + { + "id": 1, + "question": "Which property allows a nested grid to align its tracks exactly with those of its parent container?", + "options": [ + "display: contents;", + "grid-template-columns: subgrid;", + "grid-auto-flow: dense;", + "align-content: stretch;" + ], + "correct": 1, + "explanation": "The grid-template-columns: subgrid; property allows a nested grid to align its tracks with its parent container." + }, + { + "id": 2, + "question": "Which CSS feature is best for changing a component's layout based on the width of its own parent container?", + "options": [ + "Media Queries", + "Viewport Units (vw)", + "Container Queries", + "Flex-grow" + ], + "correct": 2, + "explanation": "Container Queries are used to change a component's layout based on the width of its own parent container." + }, + { + "id": 3, + "question": "If an element has width: 300px, padding: 20px, and box-sizing: border-box, what is its total rendered width?", + "options": [ + "300px", + "340px", + "360px", + "400px" + ], + "correct": 0, + "explanation": "With box-sizing: border-box, the padding is included in the width, so the total rendered width remains 300px." + }, + { + "id": 4, + "question": "What is the most semantic HTML5 element for a group of introductory content or navigation links?", + "options": [ + "
", + "
", + "
", + "