Software Engineer

The theoretical bedrock — algorithms, data structures, discrete math, architecture, operating systems, networking, databases, and computation theory. This knowledge hasn't fundamentally changed in 50+ years and forms the basis for everything else.

• Networking Fundamentals(30 concepts)

  • The OSI Model
  • Ethernet Fundamentals
  • IP Addressing: IPv4 and IPv6
  • TCP: Connection, Flow, and Congestion Control
  • DNS: Domain Name System
  • Firewall Fundamentals
  • The TCP/IP Model
  • MAC Addresses
  • Subnetting and CIDR
  • UDP Protocol
  • HTTP and HTTPS Protocols
  • VPN Technology
  • Encapsulation and Decapsulation
  • Switches and VLANs
  • Routing Fundamentals
  • Ports and Sockets
  • TLS/SSL Handshake
  • Common Network Attacks
  • Protocol Layering
  • ARP Protocol
  • NAT and DHCP
  • Reliable Data Transfer
  • Email Protocols: SMTP and IMAP
  • Network Monitoring
  • Network Standards Bodies
  • Error Detection: CRC and Checksums
  • ICMP and Traceroute
  • TCP vs. UDP Tradeoffs
  • WebSockets and Real-Time Protocols
  • Zero-Trust Architecture Concepts
• Database Theory(30 concepts)

  • Relations, Tuples, and Attributes
  • DDL Lock Levels (Reference)
  • Functional Dependencies
  • Query Execution Plans (Reference)
  • ACID: Atomicity, Consistency, Isolation, Durability
  • CAP Theorem (Reuse)
  • Relational Algebra Operations
  • DML: SELECT, INSERT, UPDATE, DELETE
  • 1NF, 2NF, 3NF, BCNF — and What Each Removes
  • Index Types: B-tree, Hash, GIN (Overview)
  • Locking and MVCC: The Two Strategies
  • Replication Strategies (Reference)
  • Primary, Foreign, and Candidate Keys
  • JOINs: Inner, Outer, Cross, Self
  • Lossless and Dependency-Preserving Decomposition
  • Query Optimizer Basics (Reuse)
  • The Four Isolation Levels
  • Sharding and Partitioning (Reuse)
  • Integrity Constraints
  • Aggregation, GROUP BY, and HAVING
  • The Read/Write Tradeoff
  • Cost Estimation — How the Planner Decides
  • Deadlocks — Detection and Resolution
  • Consensus Protocols: Raft and Paxos (Reuse)
  • Entity-Relationship Modeling
  • Subqueries vs CTEs (Reuse)
  • Schema Design Patterns (Reference)
  • EXPLAIN and Query Tuning (Reuse)
  • Write-Ahead Logging (WAL) — How Durability Works
  • Eventual vs Strong Consistency (Reuse)
• Algorithms(35 concepts)

  • Asymptotic Notation
  • Comparison Sort Algorithms
  • Linear Search
  • Shortest Path Algorithms
  • Overlapping Subproblems and Optimal Substructure
  • The Greedy Choice Property
  • Merge Sort as Divide and Conquer
  • Analyzing Iterative Algorithms
  • Non-Comparison Sorts
  • Binary Search and Variants
  • Minimum Spanning Trees
  • Memoization (Top-Down DP)
  • Activity Selection Problem
  • Closest Pair of Points
  • Analyzing Recursive Algorithms
  • Sorting Stability and In-Place Properties
  • Search in Rotated Arrays
  • Topological Sorting
  • Tabulation (Bottom-Up DP)
  • Huffman Coding
  • Karatsuba Multiplication
  • The Master Theorem
  • The Sorting Lower Bound
  • Interpolation Search
  • Strongly Connected Components
  • Classic DP Problems
  • Interval Scheduling
  • Strassen's Matrix Multiplication
  • Space Complexity Analysis
  • Practical Sorting Considerations
  • Binary Search on the Answer
  • Introduction to Network Flow
  • DP State Design Patterns
  • Greedy vs Dynamic Programming
  • Designing Divide-and-Conquer Solutions
• Computer Architecture(25 concepts)

  • Logic Gates and Truth Tables
  • Binary and Hexadecimal Systems
  • Von Neumann Architecture
  • Cache Memory Levels
  • I/O Interfaces and Buses
  • Combinational Circuits
  • Integer Representation and Two's Complement
  • Instruction Set Architecture: RISC vs. CISC
  • Cache Policies
  • Interrupts and DMA
  • Sequential Circuits and Flip-Flops
  • Floating-Point and IEEE 754
  • Instruction Cycle: Fetch-Decode-Execute
  • Virtual Memory Concepts
  • Hard Drives and SSDs
  • Arithmetic Logic Unit
  • Character Encoding: ASCII and Unicode
  • Registers and Register Files
  • Page Tables and TLBs
  • RAID Levels Overview
  • Clock Signals and Timing
  • Data Alignment and Endianness
  • Pipelining Fundamentals
  • Memory Access Patterns and Locality
  • I/O Performance Considerations
• Discrete Mathematics for Computer Science(30 concepts)

  • Propositional Logic
  • Set Theory Fundamentals
  • Counting Principles
  • Graph Theory Definitions
  • Discrete Probability Spaces
  • Divisibility and Modular Arithmetic
  • Predicate Logic and Quantifiers
  • Relations and Their Properties
  • Permutations and Combinations
  • Euler and Hamiltonian Paths
  • Conditional Probability and Bayes' Theorem
  • GCD and the Euclidean Algorithm
  • Proof Techniques
  • Functions: Injective, Surjective, Bijective
  • The Pigeonhole Principle
  • Graph Coloring
  • Random Variables and Expectation
  • Prime Numbers and Primality Testing
  • Boolean Algebra
  • Equivalence Relations
  • The Inclusion-Exclusion Principle
  • Planar Graphs
  • Randomized Algorithms: Motivation
  • Modular Exponentiation
  • Logic in Programming
  • Partial Orders
  • Introduction to Generating Functions
  • Trees and Spanning Trees (Theory)
  • Hash Function Probability Analysis
  • Number Theory in Cryptography
• Computational Thinking & Problem Solving(17 concepts)

  • Decomposition
  • The Brute-Force Approach
  • Writing Pseudocode
  • Counting Operations
  • Pattern Recognition
  • Divide and Conquer Intuition
  • Flowchart Conventions
  • Best, Worst, and Average Case
  • Abstraction
  • The Greedy Approach Intuition
  • Translating Problems to Pseudocode
  • Big-O Notation Introduction
  • Algorithm Design Thinking
  • Problem Constraints and Edge Cases
  • Tracing Execution by Hand
  • Common Growth Rates
  • Computational Thinking in Everyday Life
• Operating Systems(30 concepts)

  • What an Operating System Does
  • Process Creation: fork and exec
  • Race Conditions
  • Address Spaces
  • File System Abstractions
  • Virtual Machines vs. Containers
  • System Calls and Kernel Mode
  • Inter-Process Communication
  • Mutexes and Semaphores
  • Paging and Segmentation
  • Inodes and Directory Structures
  • Hypervisors: Type 1 and Type 2
  • The Process Concept
  • CPU Scheduling Algorithms
  • Deadlock: Conditions, Prevention, and Detection
  • Page Replacement Algorithms
  • Journaling and Crash Consistency
  • Container Runtimes
  • Process Lifecycle and States
  • Threads vs. Processes
  • The Readers-Writers Problem
  • Memory Allocation Strategies
  • File System Implementations
  • Namespaces and Cgroups
  • Context Switching
  • Thread Synchronization Primitives
  • The Producer-Consumer Problem
  • Memory-Mapped Files
  • File System Performance
  • OS-Level Virtualization Concepts
• Computation Theory(25 concepts)

  • Alphabets, Strings, and Languages
  • Deterministic Finite Automata
  • The Church-Turing Thesis
  • P vs. NP
  • Complexity in Real Software
  • Regular Expressions (Formal)
  • Non-Deterministic Finite Automata
  • Decidability and Undecidability
  • NP-Completeness
  • Computational Hardness in Cryptography
  • Context-Free Grammars
  • DFA-NFA Equivalence
  • The Halting Problem
  • Classic NP-Complete Problems
  • Heuristics for Intractable Problems
  • The Chomsky Hierarchy
  • Pushdown Automata
  • Reducibility
  • Polynomial Reductions
  • Complexity and System Design
  • Parsing Basics
  • Turing Machines
  • Rice's Theorem
  • Approximation Algorithms Introduction
  • Computational Limits Awareness
• Data Structures(35 concepts)

  • Arrays and Memory Layout
  • Singly Linked Lists
  • Stack Abstract Data Type
  • Hashing Fundamentals
  • Binary Trees and Traversals
  • Graph Representations
  • Union-Find (Disjoint Sets)
  • Dynamic Arrays and Amortized Analysis
  • Doubly Linked Lists
  • Queue Abstract Data Type
  • Collision Resolution Strategies
  • Binary Search Trees
  • Graph Traversals: BFS and DFS
  • Segment Trees
  • String Operations and Immutability
  • Circular Linked Lists
  • Deques (Double-Ended Queues)
  • Hash Table Operations and Complexity
  • Balanced BST Overview
  • Directed vs Undirected Graphs
  • Bloom Filters
  • Two-Pointer Technique
  • Linked List Operations
  • Introduction to Priority Queues
  • Hash Sets
  • Heaps and Heap Operations
  • Weighted Graphs
  • Skip Lists
  • Sliding Window Technique
  • Linked Lists vs Arrays: Tradeoffs
  • Stack and Queue Applications
  • Designing Hash Functions
  • Trie Data Structure
  • Graph Connectivity and Components
  • Choosing the Right Data Structure
• Programming Fundamentals(30 concepts)

  • Variables and Assignment
  • Conditional Statements
  • Defining and Calling Functions
  • Lists and Arrays
  • Types of Errors
  • Reading and Writing Files
  • Primitive Data Types
  • Boolean Logic and Truth Tables
  • Parameters and Return Values
  • Dictionaries and Maps
  • Exception Handling Fundamentals
  • CSV and JSON Parsing
  • Type Conversion and Coercion
  • Loop Constructs
  • Variable Scope and Lifetime
  • Sets
  • Reading Stack Traces
  • Command-Line Arguments
  • Arithmetic and Logical Expressions
  • Loop Control Flow
  • Introduction to Recursion
  • Iterating Over Collections
  • Print Debugging
  • Standard Input and Output
  • Operator Precedence
  • Nested Control Structures
  • Pure Functions vs Side Effects
  • List Comprehensions and Functional Patterns
  • Using a Debugger
  • Data Transformation Scripts

The practical craft of building software — programming languages, web development, APIs, databases, testing, version control, CI/CD, DevOps, cloud infrastructure, security, mobile, and architecture patterns. Tools evolve; the practices endure.

• APIs and Integration(25 concepts)

  • REST Principles and Constraints
  • OpenAPI and Swagger
  • GraphQL Schema Definition
  • Protocol Buffer Syntax
  • Webhooks
  • Resource Naming and URL Design
  • Auto-Generated Documentation
  • Queries, Mutations, and Subscriptions
  • gRPC Service Definitions
  • Message Queues
  • HATEOAS
  • Schema Validation
  • Resolvers
  • Streaming RPC
  • Event-Driven Architecture
  • Pagination Patterns
  • Design-First API Workflow
  • DataLoader and the N+1 Problem
  • gRPC vs REST vs GraphQL
  • API Gateway Pattern
  • API Versioning
  • Consumer-Driven Contracts
  • GraphQL vs REST Tradeoffs
  • When to Use gRPC
  • Idempotency and Retry Patterns
• Version Control and Collaboration(20 concepts)

  • Repository Concepts
  • Feature Branch Workflow
  • Interactive Rebase
  • Writing Effective Commit Messages
  • Staging, Committing, and History
  • Gitflow Workflow
  • Cherry-Picking Commits
  • Pull Request Etiquette
  • Branching and Merging
  • Trunk-Based Development
  • Bisecting to Find Bugs
  • Code Review Fundamentals
  • Remote Repositories
  • Pull Request Process
  • Git Hooks
  • Issue Tracking and Project Management
  • Resolving Merge Conflicts
  • Release Strategies
  • Submodules and Monorepo Strategies
  • Repository Documentation
• JavaScript and TypeScript(30 concepts)

  • Variables: let, const, and var
  • Callbacks and Callback Hell
  • Destructuring, Spread, and Rest
  • Type Annotations and Inference
  • Strict Mode and tsconfig.json
  • Browser APIs: DOM and Fetch
  • Data Types and Coercion
  • Promises
  • Template Literals
  • Interfaces vs Type Aliases
  • Type Narrowing and Type Guards
  • Node.js Fundamentals
  • Functions: Declaration, Expression, and Arrow
  • Async/Await
  • Modules: import and export
  • Generics
  • Discriminated Unions
  • npm and Yarn Ecosystem
  • Objects and Prototypes
  • The Event Loop Model
  • Symbols and Iterators
  • Union and Intersection Types
  • Declaration Files and Ambient Types
  • Bun and Deno Overview
  • Array Methods
  • Async Error Handling
  • Optional Chaining and Nullish Coalescing
  • Utility Types
  • Migrating JavaScript to TypeScript
  • Module Bundlers
• Web Backend Development(25 concepts)

  • Request/Response Lifecycle
  • FastAPI Fundamentals
  • Password Hashing with bcrypt
  • Router/Service/Repository Pattern
  • WebSockets
  • HTTP Methods and Semantics
  • Express Fundamentals
  • JSON Web Tokens (JWT)
  • Middleware Chains
  • Server-Sent Events (SSE)
  • HTTP Headers and Content Negotiation
  • The Middleware Pattern
  • OAuth2 and OpenID Connect
  • Background Jobs and Task Queues
  • Polling and Long Polling
  • HTTP Status Codes
  • Request Validation
  • Session-Based vs Token-Based Authentication
  • Caching Strategies with Redis
  • Pub/Sub Patterns
  • Cookies and Sessions
  • Dependency Injection
  • RBAC and ABAC
  • Rate Limiting and Throttling
  • Real-Time Architecture Considerations
• Mobile Development(25 concepts)

  • Native vs. Cross-Platform
  • React Native Core Components
  • Touch Gestures and Interactions
  • App Store Submission
  • Rendering Optimization
  • React Native Fundamentals
  • Navigation in React Native
  • Lists and Scrolling Performance
  • Code Signing and Provisioning
  • Memory Management
  • Swift and SwiftUI Overview
  • Platform-Specific Code
  • Offline-First Design
  • Over-the-Air Updates
  • Network Optimization
  • Kotlin and Jetpack Compose Overview
  • Native Modules
  • Push Notifications
  • Crash Reporting and Monitoring
  • Battery Optimization
  • Choosing a Mobile Strategy
  • Expo vs. Bare Workflow
  • Deep Linking
  • Beta Distribution
  • App Size Optimization
• Security Fundamentals(25 concepts)

  • Threat Modeling
  • OWASP Top 10 Overview
  • Symmetric Encryption (AES)
  • Secrets Management
  • GDPR Fundamentals
  • Attack Surface Analysis
  • Cross-Site Scripting (XSS)
  • Asymmetric Encryption (RSA)
  • Dependency Vulnerability Scanning
  • Data Classification
  • Defense in Depth
  • SQL Injection
  • Cryptographic Hash Functions
  • SAST and DAST
  • Encryption at Rest and in Transit
  • Principle of Least Privilege
  • Cross-Site Request Forgery (CSRF)
  • Digital Signatures
  • Security Headers
  • Security Audit Logging
  • Security vs. Usability Tradeoffs
  • Content Security Policy
  • Certificates and PKI
  • Input Validation and Sanitization
  • Incident Response Basics
• Databases in Practice(25 concepts)

  • PostgreSQL Installation and Configuration
  • SQLAlchemy for Python
  • Document Stores: MongoDB (Reuse)
  • Backup & Restore (Reuse)
  • One-to-Many and Many-to-Many Relationships
  • Window Functions and CTEs (Reuse)
  • Prisma and Drizzle for TypeScript
  • Key-Value Stores: Redis (Reuse)
  • Connection Pooling (Reuse)
  • Soft Delete Pattern (Reuse)
  • Indexes: B-tree, GIN, and Partial (Reuse)
  • Migration Management with Alembic
  • Wide-Column: Cassandra / ScyllaDB (Reuse)
  • Monitoring Performance (Reuse)
  • Audit Trail Patterns (Reuse)
  • JSONB for Semi-Structured Data (Reuse)
  • The N+1 Query Problem (Reuse)
  • Graph Databases: Neo4j (Reuse)
  • Schema Migrations in Production (Reuse)
  • Multi-Tenant Isolation Strategies (Reuse)
  • Full-Text Search in PostgreSQL (Reuse)
  • ORM vs Raw SQL Tradeoffs
  • SQL vs NoSQL Decision Rubric (Reuse)
  • Data Seeding and Fixtures
  • Event Sourcing — Introduction (Reuse)
• DevOps and CI/CD(30 concepts)

  • Continuous Integration Concepts
  • GitHub Actions
  • Docker Fundamentals
  • Kubernetes Core Concepts
  • Terraform Fundamentals
  • Structured Logging
  • Continuous Delivery vs. Continuous Deployment
  • GitLab CI/CD
  • Dockerfile Best Practices
  • Helm Charts
  • Terraform State Management
  • Metrics with Prometheus and Grafana
  • Pipeline Stages and Design
  • Jenkins Overview
  • Docker Compose
  • Health Checks and Rolling Updates
  • Modules and Reusability
  • Distributed Tracing with OpenTelemetry
  • Build Automation
  • Pipeline as Code
  • Multi-Stage Builds
  • ConfigMaps and Secrets
  • Pulumi, CDK, and Alternatives
  • Alerting Strategies
  • Artifact Management
  • Self-Hosted vs. Managed CI/CD
  • Container Registries
  • Kubernetes Networking Basics
  • GitOps Workflow
  • SLIs, SLOs, and SLAs
• Web Frontend Development(35 concepts)

  • Semantic HTML Markup
  • Components and JSX
  • Core Hooks: useState and useEffect
  • Local vs Global State
  • CSS-in-JS vs Tailwind CSS
  • Vite and Webpack
  • Server vs Client Components
  • The CSS Box Model and Layout
  • Props and State
  • Custom Hooks
  • Zustand and Redux Patterns
  • Design Tokens and Theming
  • ESLint and Prettier
  • App Router and File-Based Routing
  • CSS Flexbox
  • Event Handling
  • Context API
  • Server State with React Query
  • Component Libraries
  • Testing Infrastructure Setup
  • Data Fetching: SSR, SSG, and ISR
  • CSS Grid Layout
  • Conditional Rendering and Lists
  • Performance Optimization
  • URL State Management
  • Animation with Framer Motion
  • Performance Budgets
  • API Routes
  • Responsive Design and Media Queries
  • Component Composition
  • Suspense and Error Boundaries
  • State Machine Patterns
  • Accessibility and ARIA
  • Bundle Analysis
  • Middleware and Edge Runtime
• Python Programming(30 concepts)

  • Installing Python and Virtual Environments
  • Lists, Tuples, and Slicing
  • Classes and Instances
  • First-Class Functions and Closures
  • os, sys, and pathlib
  • Coroutines and async/await
  • The REPL and Running Scripts
  • Dictionaries and defaultdict
  • Inheritance and Polymorphism
  • Lambda Expressions
  • JSON and CSV Modules
  • The asyncio Event Loop
  • Pythonic Idioms
  • Sets and Frozensets
  • Dunder Methods (Magic Methods)
  • Map, Filter, and Reduce
  • datetime and time
  • Async Context Managers
  • Type Hints and Annotations
  • The Collections Module
  • Properties and Descriptors
  • Decorators
  • Regular Expressions
  • concurrent.futures
  • Package Management
  • Comprehensions
  • Abstract Base Classes
  • Iterators and Generators
  • Logging and argparse
  • Async vs Threading vs Multiprocessing
• Cloud Infrastructure(25 concepts)

  • IaaS, PaaS, SaaS, and FaaS
  • Virtual Machines in the Cloud
  • Object Storage (S3)
  • VPCs and Subnets
  • Multi-Tier Cloud Architecture
  • AWS, GCP, and Azure Overview
  • Managed Container Services
  • Block Storage and File Systems
  • Security Groups and Network ACLs
  • Microservices on Cloud
  • Regions and Availability Zones
  • Serverless Functions
  • Managed Database Services
  • Cloud Load Balancers
  • Event-Driven Cloud Architectures
  • Shared Responsibility Model
  • Auto-Scaling
  • Caching Services
  • DNS Management
  • Disaster Recovery in the Cloud
  • Cloud Cost Management
  • Spot and Preemptible Instances
  • CDN and Content Distribution
  • WAF and DDoS Protection
  • Well-Architected Framework
• System Architecture Patterns(30 concepts)

  • Architecture vs. Design
  • Modular Monolith
  • Microservices Architecture
  • Horizontal vs. Vertical Scaling
  • Fault Tolerance
  • Stream Processing with Kafka
  • Quality Attributes
  • Layered Architecture
  • Service Mesh
  • Database Sharding
  • Graceful Degradation
  • Batch Processing
  • Architecture Decision Records
  • Hexagonal Architecture
  • Saga Pattern
  • Read Replicas
  • Chaos Engineering
  • Lambda and Kappa Architectures
  • Tradeoff Analysis
  • Command Query Responsibility Segregation
  • Circuit Breaker Pattern
  • Caching Layers
  • Disaster Recovery Planning
  • Data Lake Patterns
  • The C4 Model
  • Event Sourcing
  • Sidecar Pattern
  • Asynchronous Processing with Queues
  • High Availability Patterns
  • Change Data Capture
• Testing and Quality Assurance(25 concepts)

  • Why Testing Matters
  • Writing Effective Unit Tests
  • Testing HTTP Endpoints
  • Browser Automation with Playwright
  • Code Linting and Formatting
  • The Testing Pyramid
  • Mocking and Stubbing
  • Database Integration Testing
  • Visual Regression Testing
  • Static Analysis
  • Test-Driven Development (TDD)
  • Test Fixtures and Factories
  • Test Isolation and Cleanup
  • Performance Testing
  • Type Checking
  • Behavior-Driven Development (BDD)
  • Code Coverage and Its Limits
  • Contract Testing
  • Accessibility Testing
  • Pre-Commit Hooks
  • The Economics of Testing
  • Property-Based Testing
  • Snapshot Testing
  • Flaky Test Management
  • Quality Gates in CI

The human side of engineering — system design, debugging methodology, technical communication, agile processes, code review, open source, career progression, and ethics. What separates junior from senior.

• System Design(25 concepts)

  • Requirements Gathering
  • Designing a URL Shortener
  • Designing a Chat Application
  • Designing a Content Delivery Network
  • Structuring Your Approach
  • Back-of-Envelope Estimation
  • Designing a Rate Limiter
  • Designing a News Feed
  • Designing a Load Balancer
  • Drawing Effective Diagrams
  • API Design Methodology
  • Designing a Key-Value Store
  • Designing a Video Streaming Platform
  • Designing a Distributed Message Queue
  • Discussing Trade-offs
  • High-Level Component Design
  • Designing a Distributed Cache
  • Designing a Search Engine
  • Designing a Distributed File System
  • Handling Ambiguity
  • Bottleneck Identification
  • Designing a Notification System
  • Designing a Ride-Sharing Service
  • Designing a Monitoring System
  • Time Management in Design Sessions
• Career Progression(25 concepts)

  • The Junior to Senior Journey
  • Writing an Engineering Resume
  • Technical Leadership
  • Technical Blogging
  • Engineering Culture
  • The Staff and Principal Path
  • Building Your Portfolio and GitHub Profile
  • Mentoring Junior Engineers
  • Conference Speaking
  • Navigating Organizational Politics
  • The Engineering Manager Path
  • Coding Interview Preparation
  • Driving Technical Decisions
  • Building a Professional Network
  • Remote, Hybrid, and Office Work
  • IC vs. Management: Making the Choice
  • Behavioral Interview Preparation
  • Cross-Team Collaboration
  • Social Media for Engineers
  • Startup vs. Enterprise
  • Competency Matrices
  • Salary Negotiation
  • Building Influence Without Authority
  • Side Projects and Visibility
  • Knowing When to Leave
• Engineering Ethics(20 concepts)

  • Utilitarianism in Software Engineering
  • Data Collection Ethics
  • Bias in Algorithms
  • Accessibility as an Ethical Obligation
  • Deontological Thinking for Engineers
  • Informed Consent in Software
  • Fairness Metrics
  • Environmental Ethics
  • Professional Codes of Conduct
  • The Right to Be Forgotten
  • Transparency and Explainability
  • The Digital Divide
  • Stakeholder Analysis
  • Dark Patterns
  • AI Safety
  • Whistleblowing in Tech
  • Ethical Decision-Making Frameworks
  • Surveillance Capitalism
  • Responsible AI Development
  • Building Inclusive Technology
• Agile and Team Processes(25 concepts)

  • The Agile Manifesto and Principles
  • Story Points vs. Time-Based Estimates
  • Cross-Functional Teams
  • Understanding Product Roadmaps
  • Translating Business Needs to Technical Work
  • The Scrum Framework
  • Planning Poker
  • Pair Programming
  • Planning Technical Spikes
  • Managing Scope
  • The Kanban Method
  • T-Shirt Sizing
  • Mob Programming
  • Managing Dependencies
  • Communicating Delays
  • Sprint Planning and Estimation
  • Breaking Down Features
  • Working Agreements
  • Risk Identification and Mitigation
  • Demo and Review Meetings
  • Velocity and Burndown Charts
  • Managing Technical Debt
  • Running Effective Retrospectives
  • Shipping Incrementally
  • Building Trust with Stakeholders
• Debugging and Troubleshooting(19 concepts)

  • The Scientific Method for Debugging
  • IDE Debuggers
  • Race Conditions and Concurrency Bugs
  • Reading Production Error Logs
  • Reproducing Bugs Reliably
  • Browser Developer Tools
  • Memory Leaks
  • Incident Triage
  • Bisecting with Git
  • Profiling CPU and Memory
  • Off-by-One Errors
  • Root Cause Analysis
  • Minimizing the Reproduction Case
  • Logging and Log Analysis
  • State Management Bugs
  • Writing Postmortems
  • Rubber Duck Debugging
  • Distributed Tracing for Debugging
  • Integration Bugs
• Code Review and Engineering Craft(25 concepts)

  • Why Code Review Matters
  • Naming Conventions
  • Creational Patterns
  • Identifying Technical Debt
  • Code Readability
  • What to Look for in Code Review
  • Function Design
  • Structural Patterns
  • Quantifying and Prioritizing Debt
  • Consistent Coding Style
  • Writing Reviewable Pull Requests
  • Writing Useful Code Comments
  • Behavioral Patterns
  • The Boy Scout Rule
  • Documentation as Code
  • Giving Effective Review Feedback
  • DRY and KISS Principles
  • When Not to Use Patterns
  • Large-Scale Refactoring Strategies
  • Working with Legacy Code
  • Code Review Checklist
  • Refactoring Patterns
  • Recognizing Anti-Patterns
  • Communicating Technical Debt to Stakeholders
  • Building for the Next Developer
• Open Source Contribution(19 concepts)

  • How Open Source Works
  • Your First Pull Request
  • Maintaining Open Source Projects
  • Portfolio Building Through Open Source
  • Open Source Licenses
  • Following Contributing Guidelines
  • Open Source Project Documentation
  • Networking Through Open Source
  • Finding Projects to Contribute To
  • Commit Message Conventions
  • Managing Issues and Pull Requests
  • Speaking at Meetups and Conferences
  • Reading Unfamiliar Codebases
  • CI Checks on Pull Requests
  • Building Community
  • Writing About Your Contributions
  • Issue Triage
  • Responding to Maintainer Review
  • Versioning and Releases with SemVer
• Technical Communication(20 concepts)

  • Technical Writing Principles
  • Explaining Technical Concepts to Non-Technical Audiences
  • Slack and Teams Communication
  • Giving Constructive Criticism
  • Types of Documentation
  • Presenting in Meetings
  • Writing Bug Reports
  • Receiving Feedback Gracefully
  • Writing Effective Commit Messages
  • Facilitating Whiteboard Sessions
  • Email Communication for Engineers
  • Preparing for One-on-One Meetings
  • RFCs and Design Documents
  • Giving Effective Standup Updates
  • Remote Collaboration Norms
  • Performance Self-Assessment
  • README Best Practices
  • Delivering Demo Presentations
  • Decision Logging
  • Radical Candor