Please enable JavaScript.
Coggle requires JavaScript to display documents.
To-Do Map - Coggle Diagram
To-Do Map
JavaScript
Execution Context
Lexical Environment
Scope
Closures
Hoisting
Temporal Dead Zone (TDZ)
this
call / apply / bind
Event Loop
Microtasks vs Macrotasks
Promises
Async / Await
Generators
Iterators
Objects
Prototypes
Prototype Chain
Classes
Property Descriptors
Symbols
Maps
Sets
WeakMap
WeakSet
Modules
Memory Management
Garbage Collection
Functional Programming
Immutability
Currying
Composition
Debounce
Throttle
Deep Clone
Event Delegation
Web APIs
Tricky Interview Questions
React
Official Documentation
Rendering
Reconciliation
Fiber
Concurrent Rendering
Scheduler
Hooks
Custom Hooks
Context
State Management
Server Components
Suspense
Lazy Loading
Memoization
Performance
Hydration
SSR
CSR
Streaming
React Compiler
Accessibility
Browser Internals
Rendering Pipeline
Critical Rendering Path
DOM
CSSOM
Render Tree
Layout
Paint
Composite
Reflow
Repaint
Browser Storage
Cookies
LocalStorage
SessionStorage
IndexedDB
Cache API
Service Workers
V8 Engine
TypeScript
Basic Types
Type Inference
Generics
Utility Types
Conditional Types
Mapped Types
Template Literal Types
Indexed Access Types
keyof
infer
Declaration Merging
Module Augmentation
Type Guards
Branded Types
Variance
Compiler Internals
Networking
OSI Model
TCP/IP
HTTP
HTTPS
HTTP/2
HTTP/3
DNS
TLS
CORS
REST
GraphQL
WebSockets
Server-Sent Events
gRPC
CDN
CSS
Specificity
Cascade
Box Model
Positioning
Flexbox
Grid
Responsive Design
Media Queries
Container Queries
Animations
Transitions
Modern CSS
CSS Architecture
Performance
Algorithms
Big O Analysis
Binary Search
Sorting Algorithms
Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Quick Sort
Heap Sort
Counting Sort
Radix Sort
BFS
DFS
Recursion
Divide and Conquer
Greedy Algorithms
Dynamic Programming
Backtracking
Sliding Window
Two Pointers
Topological Sort
Shortest Path Algorithms
Artificial Intelligence
Supervised Learning
Unsupervised Learning
Reinforcement Learning
Metrics
Bias-Variance Tradeoff
Overfitting
Underfitting
Feature Engineering
Neural Networks
Transformers
Large Language Models (LLMs)
Embeddings
Retrieval-Augmented Generation (RAG)
Vector Databases
Distributed Systems
CAP Theorem
Consensus
Raft
Paxos
Replication
Partitioning
Leader Election
Event Ordering
Distributed Transactions
Sagas
Eventual Consistency
Idempotency
Time Synchronization
System Design
Scalability
Load Balancing
Reverse Proxy
API Gateway
Caching
CDN
Message Queues
Database Scaling
Distributed Systems
Consistency Models
Rate Limiting
API Design
Build Tooling
Babel
SWC
ESBuild
Rollup
Vite
Turbopack
Rspack
Webpack
Module Resolution
Tree Shaking
Code Splitting
Databases
SQL
NoSQL
Normalization
⬜ First Normal Form (1NF)
Second Normal Form (2NF)
Third Normal Form (3NF)
Boyce-Codd Normal Form (BCNF)
Fourth Normal Form (4NF)
Indexes
Transactions
ACID
Isolation Levels
Query Optimization
Replication
Sharding
CAP Theorem
Data Structures
Arrays
Linked Lists
Stacks
Queues
Hash Tables
Heaps
Trees
Tries
Graphs
Union Find
Bloom Filters
Software Architecture
Layered Architecture
Hexagonal Architecture
Clean Architecture
Onion Architecture
CQRS
Event Sourcing
MVC
MVVM
Backend for Frontend (BFF)
Pipes and Filters
Space-Based Architecture
Security
Authentication
Authorization
OAuth
JWT
XSS
CSRF
SQL Injection
CSP
Same-Origin Policy
Encryption
Engineering Productivity
Git Internals
Compilers
AST
Babel
SWC
ESBuild
Vite
Webpack
Build Systems
Bundlers
API Engineering
REST
GraphQL
gRPC
OpenAPI
Versioning
Pagination
Filtering
HATEOAS
API Security
Rate Limiting
Cloud Computing
AWS
Azure
GCP
Serverless
Object Storage
CDN
IAM
Load Balancers
Managed Databases
Cloud Networking
Frontend Performance
Core Web Vitals
Lighthouse
Bundle Analysis
Critical CSS
Image Optimization
Font Optimization
Lazy Loading
Resource Hints
Web Workers
OffscreenCanvas
Software Engineering
SOLID
Design Patterns
Clean Code
Refactoring
Object-Oriented Programming
Functional Programming
Domain-Driven Design
Event-Driven Architecture
Monoliths
Microservices
DevOps
Git
Linux
Docker
Kubernetes
CI/CD
Infrastructure as Code
Terraform
Monitoring
Logging
Observability
Computer Architecture
CPU Architecture
Instruction Set Architecture (ISA)
Memory Hierarchy
Cache (L1/L2/L3)
Cache Coherency
CPU Pipeline
Branch Prediction
SIMD
NUMA
Hardware Interrupts
Frontend Architecture
Component Architecture
State Management Patterns
Design Systems
Monorepos
Module Federation
Micro Frontends
Rendering Strategies
Accessibility Architecture
Performance Budgets
Operating Systems
Processes
Threads
Scheduling
Memory Management
Virtual Memory
Synchronization
Deadlocks
File Systems
Compiler Engineering
Lexical Analysis
Parsing
AST
Intermediate Representation (IR)
Optimization Passes
Code Generation
JIT Compilation
LLVM
Performance Engineering
CPU Profiling
Memory Profiling
Flame Graphs
Benchmarking
Performance Budgets
Memory Leaks
GC Profiling
Optimization Strategies
Observability
Metrics
Logs
Tracing
OpenTelemetry
Prometheus
Grafana
Jaeger
Alerting
Debugging
Chrome DevTools
Node.js Inspector
Heap Snapshots
Memory Leak Detection
Performance Timeline
Network Analysis
Source Maps
Remote Debugging
UI Engineering
Typography
Color Theory
Motion Design
Design Tokens
Responsive Systems
CSS Architecture
Internationalization (i18n)
Localization (l10n)
Programming Paradigms
Imperative Programming
Declarative Programming
Object-Oriented Programming
Functional Programming
Reactive Programming
Concurrent Programming
Event-Driven Programming
Testing
Unit Testing
Integration Testing
End-to-End Testing
Mocking
Test Doubles
TDD
Performance Testing
Package Management
npm
pnpm
Yarn
Lockfiles
Semantic Versioning
Workspaces
Monorepos
Finance
Budgeting
Saving
Investing
Taxes
Insurance
Retirement Planning
Mathematics (Advanced)
Linear Algebra
Probability
Statistics
Calculus
Discrete Mathematics
Graph Theory
Psychology
Cognitive Biases
Decision Making
Habits
Motivation
Emotional Intelligence
Stress Management
Search Systems
Full-Text Search
Inverted Index
Elasticsearch
Ranking Algorithms
Search Relevance
Communication
Writing
Public Speaking
Negotiation
Active Listening
Conflict Resolution
HTML
Semantic HTML
Forms
Accessibility
SEO
Browser Parsing
Computer Science Theory
Automata Theory
Formal Languages
Computability Theory
Computational Complexity
Information Theory
Message Brokers
Apache Kafka
RabbitMQ
NATS
Redis Streams
Apache Pulsar
Health
Nutrition
Exercise
Sleep
First Aid
Preventive Healthcare
Philosophy
Ethics
Logic
Critical Thinking
Stoicism
Epistemology
Law
Contracts
Employment Law
Consumer Rights
Intellectual Property
Privacy
Mathematics (Basics)
Arithmetic
Algebra
Statistics
Probability
Logic
Economics
Microeconomics
Macroeconomics
Incentives
Market Dynamics
Science
Physics
Chemistry
Biology
Astronomy
Personal Productivity
Time Management
Note Taking
Learning Techniques
Goal Setting
Home & Practical Skills
Cooking ✅
Cleaning ✅
Basic Repairs ✅
Car Maintenance
Check engine oil level
Change oil and oil filter
Check coolant level
Check brake fluid
Check power steering fluid
Top up washer fluid
Check tire pressure
Rotate tires
Check tire tread and alignment
Inspect brake pads and rotors
Test battery and clean terminals
Replace air filter
Replace cabin air filter
Inspect belts and hoses
Check lights and wipers
Schedule regular service
Cybersecurity
Password Security
Phishing
Privacy
Digital Identity
Survival Skills
Navigation
Emergency Preparedness
Fire Safety
Water Safety
Geography
Countries
Climate
Geopolitics
Languages
English
Native Language
Second Foreign Language
Politics
Political Systems
International Relations
Public Policy