Skip to content

CHRISTIAN SOFTWAREREFERENCE SERIES EDITION 2026.10

An open reference for computer science and software engineering.

[ Search the manual ]·PT

Home SDE II path Topics Study tracks Search the manual GitHub ↗

Index / Browse by category

Foundations of Computing

Programming fundamentals: control flow, functions and loop invariants
Data types and representation: integers, bytes, text and precision
Logic, Proof Techniques and Loop Invariants
Programming Semantics, Aliasing and Executable Contracts
Programming memory: references, aliasing and object lifetimes
C programming foundations: pointers, arrays, bounds and object lifetimes
Discrete Mathematics: Sets, Counting and Exact Probability
Binary Relations, Equivalence Classes and Partial Orders
Asymptotic Analysis and Algorithmic Cost
Floating-point reasoning: rounding, cancellation and compensated summation
Numerically stable statistics: online mean and Welford variance
Number theory fundamentals: divisibility, GCD and the Euclidean algorithm
Modular arithmetic: congruences, inverses and fast exponentiation
Algorithmic reasoning: specifications, brute force, invariants and optimization
Recursion, Call Stacks and Divide-and-Conquer
Solving Algorithmic Recurrences: Trees, Substitution and Master Theorem
Python error contracts: exceptions and resource cleanup
File and data fundamentals: bytes, UTF-8, JSON schemas and safe boundaries
From C source to executable: preprocessing, object files and linking
Formal Languages and Finite Automata: DFA, NFA, Epsilon Closure and Determinization
Context-Free Grammars, Pushdown Automata and Syntax Analysis
An Expression Compiler: Lexing, Precedence Parsing, AST, Bytecode and Virtual Machine
Static Type Checking, Lexical Scopes and a Typed Expression Compiler
Typed Functions, Lexical Closures and Bytecode Call Frames
Mutable Cells, Shared Closures and Typed Recursive Functions
Lexical Addresses, Typed Bytecode Verification and a Slot-Based Virtual Machine
Versioned Bytecode Serialization, Integrity Checks and Verified Loading
Heap Reachability, Object Lifetimes and Stop-the-World Mark-and-Sweep
Garbage Collection Inside the Slot VM: Roots, Closures and Recursive Cycles

Computer Architecture

Digital logic fundamentals: Boolean gates, truth tables and binary adders
Sequential logic fundamentals: clocked state, registers and finite-state machines
Machine Representation, CPU Instructions and Cache Mapping
CPU fundamentals: datapath, control and the fetch–decode–execute cycle
CPU Pipelines: Data Hazards, Forwarding and Branch Prediction

Data Structures & Algorithms

Arrays and Strings: Representation, Costs and Correct Iteration
Abstract data types: interfaces, representation invariants and costs
Dynamic arrays: capacity, shrinking and amortized analysis
Linked Lists: Nodes, Reversal, Cycles and Ownership
Stacks and Queues: LIFO, FIFO, Deques and Invariants
Hash Tables, Collisions and Invariants
Binary Trees and BSTs: Traversals, Ordering and Height
Binary Heaps and Priority Queues
Graph Traversal with BFS and DFS
Sorting Algorithms: Stability, Mergesort, Quicksort and Heapsort
Binary Search: Bounds, Invariants and Monotone Predicates
Two Pointers and Prefix Sums: Invariants and Subarray Queries
Two Pointers and Sliding Windows
Monotonic Stacks: Next Greater, Temperatures and Histogram Areas
Tree Algorithms: Level Order, LCA, Diameter and BST Validation
Shortest Paths: Dijkstra, Bellman–Ford and Negative Cycles
Greedy Interval Scheduling: Exchange Proofs and Counterexamples
Backtracking: State Spaces, Pruning and Correctness
Dynamic Programming: States and Recurrences
Tries, Prefix Search and String Keys
Disjoint Set Union: Connectivity, Compression and Kruskal
Strongly Connected Components and Condensation Graphs
Maximum Flow, Minimum Cuts and Bipartite Matching

Operating Systems & Concurrency

How programs run: command-line arguments, environment, streams and exit status
Processes, Virtual Memory and System Calls
Heap Allocation: Free Lists, Fragmentation and Coalescing
File Descriptors, Buffered I/O and fsync Crash Boundaries
Filesystem Internals: Inodes, Block Allocation, Journaling and Recovery
CPU Scheduling: FCFS, Round Robin, Response and Fairness
Concurrency: Races, Locks, Conditions and Deadlocks
Priority Scheduling: MLFQ, Aging and Priority Inheritance
Memory Models: Atomics, Happens-Before and Visibility
C++17 Engineering Workshop: Thread-Safe Token Bucket and CI

Computer Networks

HTTP fundamentals: requests, responses, methods and client-server boundaries
IP Routing and DNS: Prefix Selection, Resolution and TTL Caches
IP Packet Size: IPv4 Fragmentation and Path MTU Discovery
DNS Authority, CNAME Chains and Negative Caching
Networking Fundamentals: DNS, TCP, TLS and HTTP
TCP Byte Streams: Message Framing, ACKs and Flow Control
TCP Retransmission Timers: RTT Estimation, Karn's Rule and Congestion Windows

Security & Cryptography

TLS 1.3: Handshake Authentication, HKDF and Traffic Keys
API Security: Identity, Authorization and Threat Models
OAuth 2.0 Security: PKCE, Token Binding and Replay

Software Engineering & Design

Modular programming: cohesion, explicit interfaces and pure functions
Git fundamentals: working tree, index, commits and branch history
Testing, Contracts and Maintainable Changes
Clean Code Fundamentals: Cohesion, Coupling and Change-Safe Design
Object-Oriented Design: Encapsulation, Composition and Polymorphism
Low-Level Design: Contracts, State Machines and Dependency Boundaries
SOLID, Dependency Inversion and Behavioral Contracts
Software architecture: dependency boundaries and modular design
Domain modeling: entities, value objects and aggregate invariants
Software Testing Strategies: Units, Contracts, Integration and E2E
Refactoring and Design Patterns: Strategy, Adapter and Behavior Preservation
Design Pattern Families: Builder, Facade and Observer
State and Command patterns: transitions, replay and failure contracts
Creational patterns: Factory Method, Abstract Factory and simple factories
Debugging and Profiling: Reproduction, CPU, Memory and Tracing
Build fundamentals: dependency graphs, incremental compilation and GNU Make
Maintainable Implementation Workshop: Token Bucket, Clock Injection and Tests
Software Project Lifecycle: From Requirements to Operations
CI/CD and Release Engineering: Canary, Schema Evolution and Rollback
Production Incident Response, Recovery and Postmortems
Formal Verification: Invariants, State Exploration and TLA+
Property-Based Algorithm Testing: Oracles, Shrinking and Metamorphic Checks

Databases & Storage

Relational database fundamentals: keys, joins and data integrity
SQLite application fundamentals: parameterized CRUD and atomic transactions
SQLite schema migrations: user_version, compatibility and rollback
Transactions, Isolation and Distributed Consistency
Transactional Indexes: MVCC, Uniqueness and Serializable Isolation
SQL Query Planning: Selectivity, Statistics, Indexes and Joins
Database Storage: Pages, MVCC, B-Trees and Write-Ahead Logs
Database Replication, Failover and Data Loss Boundaries

Distributed Systems

Caching: Correctness, Invalidation and Failure
Load Balancing: Capacity, Routing and Failure Recovery
Rate Limiting: Token Buckets and Distributed Guarantees
Queues, Delivery Semantics and Idempotency
Data Partitioning and Sharding: Keys, Hotspots and Rebalancing
Distributed Consensus: Raft, Quorums and Replicated Logs
Network Partition Models: Exhaustive Quorum Connectivity Checks
Observability: Metrics, Logs, Traces and SLOs

System Design

Capacity Estimation and System Constraints
System Design Method: Requirements, Sizing, Interfaces and Failures
HTTP API Contracts: Pagination, Idempotency and Conditional Updates
Storage Selection: Relational, Document, Key-Value and Object Stores
Service Boundaries: Modular Monoliths, Microservices and Events
Reliable APIs: Timeouts, Retries, Idempotency and Backpressure
System design: authoritative writes, projections and consistency
System Design Case Study: Durable Multi-Channel Notifications
Case Study: Design a URL Shortener
System Design Case: Orders, Inventory Reservations and Payments
System design: ticket holds, concurrent booking and expiry
System Design Case: Social Feed, Fanout and Timeline Ranking
System Design Architecture Review: Checkout Invariants and Recovery

Assessment & Engineering Judgment

Algorithm Interview Workshop: Interval Rooms and Negative-Sum Windows
Independent Coding Assessment: Coupon Routes and Parallel Task Rounds
Independent Coding Assessment II: Minimax Batches and Dynamic Islands
Independent Assessment III: Dynamic Programming and Idempotent Event Processing
Legacy-Code Assessment: Characterization, Tenant Scoping and Safe Pagination
System Design Interview Workshop: Multi-Tenant Webhook Delivery
Adaptive System Design Drill: Document Processing Under Changing Requirements
Independent System Design Assessment: Usage Metering, Late Events and Billing Reconciliation
Explaining Engineering Decisions with Evidence
Concurrency Interview Workshop: Races, CAS and Interleavings
Fault-Injection Workshop: Durable Outbox, Crashes and Duplicate Delivery

Specialized Systems Laboratories

PostgreSQL Integration Lab: Concurrent Reservations and Crash Recovery
PostgreSQL Serializable Lab: Write Skew and Whole-Transaction Retries
SQLite Multi-Process Workshop: Atomic Reservations and Crash Recovery
PostgreSQL Physical Replication Lab: Standby Replay and Manual Promotion
PostgreSQL Failover Safety: Fencing Receipts and Promotion Gates
PostgreSQL Recovery Measurements: RPO, RTO and Network Split
RabbitMQ Integration Lab: Redelivery and Transactional Inbox
RabbitMQ Restart Lab: Durable Queues and Confirmed Messages
RabbitMQ Quorum Leader Failover: Three-Node Executable Lab
RabbitMQ Quorum Majority Loss: Fail Closed and Recover Writes
RabbitMQ Live Network Partition: Running Brokers Without a Quorum

Study tracks →

INDEX

All chapters →

Foundations of Computing

Programming fundamentals: control flow, functions and loop invariants
Data types and representation: integers, bytes, text and precision
Logic, Proof Techniques and Loop Invariants
Programming Semantics, Aliasing and Executable Contracts
Programming memory: references, aliasing and object lifetimes
C programming foundations: pointers, arrays, bounds and object lifetimes
Discrete Mathematics: Sets, Counting and Exact Probability
Binary Relations, Equivalence Classes and Partial Orders
Asymptotic Analysis and Algorithmic Cost
Floating-point reasoning: rounding, cancellation and compensated summation
Numerically stable statistics: online mean and Welford variance
Number theory fundamentals: divisibility, GCD and the Euclidean algorithm
Modular arithmetic: congruences, inverses and fast exponentiation
Algorithmic reasoning: specifications, brute force, invariants and optimization
Recursion, Call Stacks and Divide-and-Conquer
Solving Algorithmic Recurrences: Trees, Substitution and Master Theorem
Python error contracts: exceptions and resource cleanup
File and data fundamentals: bytes, UTF-8, JSON schemas and safe boundaries
From C source to executable: preprocessing, object files and linking
Formal Languages and Finite Automata: DFA, NFA, Epsilon Closure and Determinization
Context-Free Grammars, Pushdown Automata and Syntax Analysis
An Expression Compiler: Lexing, Precedence Parsing, AST, Bytecode and Virtual Machine
Static Type Checking, Lexical Scopes and a Typed Expression Compiler
Typed Functions, Lexical Closures and Bytecode Call Frames
Mutable Cells, Shared Closures and Typed Recursive Functions
Lexical Addresses, Typed Bytecode Verification and a Slot-Based Virtual Machine
Versioned Bytecode Serialization, Integrity Checks and Verified Loading
Heap Reachability, Object Lifetimes and Stop-the-World Mark-and-Sweep
Garbage Collection Inside the Slot VM: Roots, Closures and Recursive Cycles

Computer Architecture

Digital logic fundamentals: Boolean gates, truth tables and binary adders
Sequential logic fundamentals: clocked state, registers and finite-state machines
Machine Representation, CPU Instructions and Cache Mapping
CPU fundamentals: datapath, control and the fetch–decode–execute cycle
CPU Pipelines: Data Hazards, Forwarding and Branch Prediction

Data Structures & Algorithms

Arrays and Strings: Representation, Costs and Correct Iteration
Abstract data types: interfaces, representation invariants and costs
Dynamic arrays: capacity, shrinking and amortized analysis
Linked Lists: Nodes, Reversal, Cycles and Ownership
Stacks and Queues: LIFO, FIFO, Deques and Invariants
Hash Tables, Collisions and Invariants
Binary Trees and BSTs: Traversals, Ordering and Height
Binary Heaps and Priority Queues
Graph Traversal with BFS and DFS
Sorting Algorithms: Stability, Mergesort, Quicksort and Heapsort
Binary Search: Bounds, Invariants and Monotone Predicates
Two Pointers and Prefix Sums: Invariants and Subarray Queries
Two Pointers and Sliding Windows
Monotonic Stacks: Next Greater, Temperatures and Histogram Areas
Tree Algorithms: Level Order, LCA, Diameter and BST Validation
Shortest Paths: Dijkstra, Bellman–Ford and Negative Cycles
Greedy Interval Scheduling: Exchange Proofs and Counterexamples
Backtracking: State Spaces, Pruning and Correctness
Dynamic Programming: States and Recurrences
Tries, Prefix Search and String Keys
Disjoint Set Union: Connectivity, Compression and Kruskal
Strongly Connected Components and Condensation Graphs
Maximum Flow, Minimum Cuts and Bipartite Matching

Operating Systems & Concurrency

How programs run: command-line arguments, environment, streams and exit status
Processes, Virtual Memory and System Calls
Heap Allocation: Free Lists, Fragmentation and Coalescing
File Descriptors, Buffered I/O and fsync Crash Boundaries
Filesystem Internals: Inodes, Block Allocation, Journaling and Recovery
CPU Scheduling: FCFS, Round Robin, Response and Fairness
Concurrency: Races, Locks, Conditions and Deadlocks
Priority Scheduling: MLFQ, Aging and Priority Inheritance
Memory Models: Atomics, Happens-Before and Visibility
C++17 Engineering Workshop: Thread-Safe Token Bucket and CI

Computer Networks

HTTP fundamentals: requests, responses, methods and client-server boundaries
IP Routing and DNS: Prefix Selection, Resolution and TTL Caches
IP Packet Size: IPv4 Fragmentation and Path MTU Discovery
DNS Authority, CNAME Chains and Negative Caching
Networking Fundamentals: DNS, TCP, TLS and HTTP
TCP Byte Streams: Message Framing, ACKs and Flow Control
TCP Retransmission Timers: RTT Estimation, Karn's Rule and Congestion Windows

Security & Cryptography

TLS 1.3: Handshake Authentication, HKDF and Traffic Keys
API Security: Identity, Authorization and Threat Models
OAuth 2.0 Security: PKCE, Token Binding and Replay

Software Engineering & Design

Modular programming: cohesion, explicit interfaces and pure functions
Git fundamentals: working tree, index, commits and branch history
Testing, Contracts and Maintainable Changes
Clean Code Fundamentals: Cohesion, Coupling and Change-Safe Design
Object-Oriented Design: Encapsulation, Composition and Polymorphism
Low-Level Design: Contracts, State Machines and Dependency Boundaries
SOLID, Dependency Inversion and Behavioral Contracts
Software architecture: dependency boundaries and modular design
Domain modeling: entities, value objects and aggregate invariants
Software Testing Strategies: Units, Contracts, Integration and E2E
Refactoring and Design Patterns: Strategy, Adapter and Behavior Preservation
Design Pattern Families: Builder, Facade and Observer
State and Command patterns: transitions, replay and failure contracts
Creational patterns: Factory Method, Abstract Factory and simple factories
Debugging and Profiling: Reproduction, CPU, Memory and Tracing
Build fundamentals: dependency graphs, incremental compilation and GNU Make
Maintainable Implementation Workshop: Token Bucket, Clock Injection and Tests
Software Project Lifecycle: From Requirements to Operations
CI/CD and Release Engineering: Canary, Schema Evolution and Rollback
Production Incident Response, Recovery and Postmortems
Formal Verification: Invariants, State Exploration and TLA+
Property-Based Algorithm Testing: Oracles, Shrinking and Metamorphic Checks

Databases & Storage

Relational database fundamentals: keys, joins and data integrity
SQLite application fundamentals: parameterized CRUD and atomic transactions
SQLite schema migrations: user_version, compatibility and rollback
Transactions, Isolation and Distributed Consistency
Transactional Indexes: MVCC, Uniqueness and Serializable Isolation
SQL Query Planning: Selectivity, Statistics, Indexes and Joins
Database Storage: Pages, MVCC, B-Trees and Write-Ahead Logs
Database Replication, Failover and Data Loss Boundaries

Distributed Systems

Caching: Correctness, Invalidation and Failure
Load Balancing: Capacity, Routing and Failure Recovery
Rate Limiting: Token Buckets and Distributed Guarantees
Queues, Delivery Semantics and Idempotency
Data Partitioning and Sharding: Keys, Hotspots and Rebalancing
Distributed Consensus: Raft, Quorums and Replicated Logs
Network Partition Models: Exhaustive Quorum Connectivity Checks
Observability: Metrics, Logs, Traces and SLOs

System Design

Capacity Estimation and System Constraints
System Design Method: Requirements, Sizing, Interfaces and Failures
HTTP API Contracts: Pagination, Idempotency and Conditional Updates
Storage Selection: Relational, Document, Key-Value and Object Stores
Service Boundaries: Modular Monoliths, Microservices and Events
Reliable APIs: Timeouts, Retries, Idempotency and Backpressure
System design: authoritative writes, projections and consistency
System Design Case Study: Durable Multi-Channel Notifications
Case Study: Design a URL Shortener
System Design Case: Orders, Inventory Reservations and Payments
System design: ticket holds, concurrent booking and expiry
System Design Case: Social Feed, Fanout and Timeline Ranking
System Design Architecture Review: Checkout Invariants and Recovery

Assessment & Engineering Judgment

Algorithm Interview Workshop: Interval Rooms and Negative-Sum Windows
Independent Coding Assessment: Coupon Routes and Parallel Task Rounds
Independent Coding Assessment II: Minimax Batches and Dynamic Islands
Independent Assessment III: Dynamic Programming and Idempotent Event Processing
Legacy-Code Assessment: Characterization, Tenant Scoping and Safe Pagination
System Design Interview Workshop: Multi-Tenant Webhook Delivery
Adaptive System Design Drill: Document Processing Under Changing Requirements
Independent System Design Assessment: Usage Metering, Late Events and Billing Reconciliation
Explaining Engineering Decisions with Evidence
Concurrency Interview Workshop: Races, CAS and Interleavings
Fault-Injection Workshop: Durable Outbox, Crashes and Duplicate Delivery

Specialized Systems Laboratories

PostgreSQL Integration Lab: Concurrent Reservations and Crash Recovery
PostgreSQL Serializable Lab: Write Skew and Whole-Transaction Retries
SQLite Multi-Process Workshop: Atomic Reservations and Crash Recovery
PostgreSQL Physical Replication Lab: Standby Replay and Manual Promotion
PostgreSQL Failover Safety: Fencing Receipts and Promotion Gates
PostgreSQL Recovery Measurements: RPO, RTO and Network Split
RabbitMQ Integration Lab: Redelivery and Transactional Inbox
RabbitMQ Restart Lab: Durable Queues and Confirmed Messages
RabbitMQ Quorum Leader Failover: Three-Node Executable Lab
RabbitMQ Quorum Majority Loss: Fail Closed and Recover Writes
RabbitMQ Live Network Partition: Running Brokers Without a Quorum

Study tracks

Amazon SDE II — Core Interview Path
Computer Science — Core Curriculum
Advanced Systems — Optional Laboratories

Home / Search the manual

Search the manual

Search chapters, diagrams and concepts

Search the manual

Enter a term to search the entire reference.

On this page

Engineering Manual

Reviewed 2026-10-12

Authored and edited by Christian Rafael de Souza Silva Software Engineer · Data Science Technologist Postgraduate Degree in Electronic Engineering and Robotics

Home · Portfolio · Study tracks