Takashi's Notes

  • adrs
    • Qualities of an Architecture Decision Record
    • Use Linux
    • Use Rust
  • algorithms
    • binary-search
      • 63 Tree Sum
      • 78 Zero Matrix
      • 132 Height Balanced Tree
      • 251 Univalue Tree
      • 867 Count Nodes in Complete Binary Tree
    • cp-algorithms
      • Binary Exponentation
      • Minimum Queue
      • Minimum Stack
    • cses
      • additional-problems
        • Acyclic Graph Edges
        • advertisement
        • area-of-rectangles
        • binary-subsequences
        • bit-inversions
        • bit-problem
        • bit-substrings
        • book-shop-ii
        • chess-tournament
        • coding-company
        • coin-arrangement
        • coin-grid
        • counting-bishops
        • counting-bits
        • counting-reorders
        • counting-sequences
        • course-schedule-ii
        • creating-offices
        • critical-cities
        • cyclic-array
        • empty-string
        • even-outdegree-edges
        • filling-trominos
        • flight-route-requests
        • food-division
        • forbidden-cities
        • functional-graph-distribution
        • graph-girth
        • grid-completion
        • grid-path-construction
        • grid-paths
        • grid-puzzle-i
        • grid-puzzle-ii
        • increasing-array-ii
        • increasing-subsequence-ii
        • intersection-points
        • inverse-inversions
        • letter-pair-move-game
        • list-of-sums
        • maximum-building-i
        • maximum-building-ii
        • maximum-xor-subarray
        • missing-coin-sum-queries
        • monotone-subsequences
        • movie-festival-queries
        • multiplication-table
        • network-breakdown
        • network-renovation
        • new-flight-routes
        • number-grid
        • permutation-inversions
        • permutations-ii
        • programmers-and-artists
        • Prufer Code
        • pyramid-array
        • removing-digits-ii
        • reversal-sorting
        • robot-path
        • school-excursion
        • shortest-subsequence
        • sorting-methods
        • special-substrings
        • stack-weights
        • stick-divisions
        • string-removals
        • string-reorder
        • string-transform
        • strongly-connected-edges
        • swap-game
        • swap-round-sorting
        • tree-isomorphism-i
        • tree-isomorphism-ii
        • tree-traversals
        • two-stacks-sorting
        • visiting-cities
        • writing-numbers
        • xor-pyramid
      • advanced-techniques
        • apples-and-bananas
        • beautiful-subgrids
        • cut-and-paste
        • distinct-routes-ii
        • dynamic-connectivity
        • eulerian-subgraphs
        • hamming-distance
        • houses-and-schools
        • knuth-division
        • meet-in-the-middle
        • monster-game-i
        • monster-game-ii
        • necessary-cities
        • necessary-roads
        • new-roads-queries
        • one-bit-positions
        • parcel-delivery
        • reachability-queries
        • reachable-nodes
        • reversals-and-sums
        • signal-processing
        • subarray-squares
        • substring-reversals
        • task-assignment
      • dynamic-programming
        • array-description
        • book-shop
        • coin-combinations-i
        • coin-combinations-ii
        • counting-numbers
        • counting-tilings
        • counting-towers
        • dice-combinations
        • edit-distance
        • elevator-rides
        • grid-paths
        • increasing-subsequence
        • minimizing-coins
        • money-sums
        • projects
        • rectangle-cutting
        • removal-game
        • removing-digits
        • two-sets-ii
      • geometry
        • convex-hull
        • line-segment-intersection
        • minimum-euclidean-distance
        • point-in-polygon
        • point-location-test
        • polygon-area
        • polygon-lattice-points
      • graph-algorithms
        • building-roads
        • building-teams
        • coin-collector
        • counting-rooms
        • course-schedule
        • cycle-finding
        • de-bruijn-sequence
        • distinct-routes
        • download-speed
        • flight-discount
        • flight-routes
        • flight-routes-check
        • game-routes
        • giant-pizza
        • hamiltonian-flights
        • high-score
        • investigation
        • knights-tour
        • labyrinth
        • longest-flight-route
        • mail-delivery
        • message-route
        • monsters
        • planets-and-kingdoms
        • planets-cycles
        • planets-queries-i
        • planets-queries-ii
        • police-chase
        • road-construction
        • road-reparation
        • round-trip
        • round-trip-ii
        • school-dance
        • shortest-routes-i
        • shortest-routes-ii
        • teleporters-path
      • introductory
        • apple-division
        • bit-strings
        • chessboard-and-queens
        • coin-piles
        • creating-strings
        • digit-queries
        • gray-code
        • grid-paths
        • Increasing Array
        • Missing Number
        • Number Spiral
        • palindrome-reorder
        • Permutations
        • Repetitions
        • tower-of-hanoi
        • trailing-zeros
        • two-knights
        • two-sets
        • Weird Algorithm
      • mathematics
        • another-game
        • binomial-coefficients
        • bracket-sequences-i
        • bracket-sequences-ii
        • candy-lottery
        • christmas-party
        • common-divisors
        • counting-coprime-pairs
        • counting-divisors
        • counting-grids
        • counting-necklaces
        • creating-strings-ii
        • dice-probability
        • distributing-apples
        • divisor-analysis
        • exponentiation
        • exponentiation-ii
        • fibonacci-numbers
        • graph-paths-i
        • graph-paths-ii
        • grundys-game
        • inversion-probability
        • josephus-queries
        • moving-robots
        • nim-game-i
        • nim-game-ii
        • prime-multiples
        • stair-game
        • stick-game
        • sum-of-divisors
        • throwing-dice
      • range-queries
        • distinct-values-queries
        • dynamic-range-minimum-queries
        • dynamic-range-sum-queries
        • forest-queries
        • forest-queries-ii
        • hotel-queries
        • increasing-array-queries
        • list-removals
        • pizzeria-queries
        • polynomial-queries
        • prefix-sum-queries
        • range-queries-and-copies
        • range-update-queries
        • range-updates-and-sums
        • range-xor-queries
        • salary-queries
        • static-range-minimum-queries
        • static-range-sum-queries
        • subarray-sum-queries
      • sorting-and-searching
        • apartments
        • Array Division
        • Collecting Numbers II
        • collecting-numbers
        • Concert Tickets
        • distinct-numbers
        • factory-machines
        • ferris-wheel
        • josephus-problem-i
        • josephus-problem-ii
        • maximum-subarray-sum
        • maximum-subarray-sum-ii
        • missing-coin-sum
        • movie-festival
        • movie-festival-ii
        • Nearest Smaller Values
        • nested-ranges-check
        • nested-ranges-count
        • playlist
        • reading-books
        • restaurant-customers
        • room-allocation
        • sliding-cost
        • sliding-median
        • stick-lengths
        • subarray-distinct-values
        • subarray-divisibility
        • subarray-sums-i
        • subarray-sums-ii
        • sum-of-four-values
        • sum-of-three-values
        • sum-of-two-values
        • tasks-and-deadlines
        • towers
        • traffic-lights
      • string-algorithms
        • counting-patterns
        • distinct-substrings
        • finding-borders
        • finding-patterns
        • finding-periods
        • longest-palindrome
        • minimal-rotation
        • palindrome-queries
        • pattern-positions
        • repeating-substring
        • required-substring
        • string-functions
        • string-matching
        • substring-distribution
        • substring-order-i
        • substring-order-ii
        • word-combinations
      • tree-algorithms
        • company-queries-i
        • company-queries-ii
        • counting-paths
        • distance-queries
        • distinct-colors
        • finding-a-centroid
        • fixed-length-paths-i
        • fixed-length-paths-ii
        • path-queries
        • path-queries-ii
        • subordinates
        • subtree-queries
        • tree-diameter
        • tree-distances-i
        • tree-distances-ii
        • tree-matching
    • ctci
      • cpp
        • arrays
          • ctci-cpp-arrays
        • ctci-C++
      • rust
        • arrays
          • ctci-rust-arrays
        • CTCI in Rust
    • interview-questions
      • bfs
      • calculate-best-discount
      • insert-interval
      • lowest-common-ancestor-in-binary-tree
      • shortest-path-in-binary-matrix
    • leetcode
      • explanations
        • 62-unique-paths
        • 104-maximum-depth-of-binary-tree
      • rust
        • binary-tree-inorder-traversal-rs
        • Two Sum
        • valid-parentheses-rs
  • artificial-intelligence
    • Links
    • The Bitter Lesson
  • blockchain
    • proof-of-work
    • Types of PoS
  • books
    • a-tour-of-cpp
      • algorithms
      • classes
      • concepts-and-generic-programming
      • concurrency
      • containers
      • essential-operations
      • history-and-compatibility
      • input-and-output
      • library-overview
      • modularity
      • numerics
      • strings-and-regular-expressions
      • templates
      • the-basics
      • user-defined-types
      • utilities
    • algorithms-by-jeff-erickson
      • All-Pairs Shortest Paths
      • Applications of Flows and Cuts
      • Backtracking
      • Basic Graph Algorithms
      • Depth-First Search
      • Dynamic Programming
      • Greedy Algorithms
      • Introduction
      • Maximum Flows and Minimum Cuts
      • Minimum Spanning Trees
      • NP-Hardness
      • Recursion
      • Shortest Paths
    • category-theory-for-programmers
      • adjuctions
      • algebras-for-monads
      • categories-great-and-small
      • category-the-essence-of-composition
      • comonads
      • declarative-programming
      • ends-and-coends
      • enriched-categories
      • f-algebras
      • free-monoids
      • freeforgetful-adjunctions
      • function-types
      • functoriality
      • functors
      • its-all-about-morphisms
      • kan-extensions
      • kleisli-categories
      • lawvere-theories
      • limits-and-colimits
      • monads-and-effects
      • monads-categorically
      • monads-monoids-and-categories
      • monads-programmers-definition
      • natural-transformations
      • products-and-coproducts
      • representable-functors
      • simple-algebraic-data-types
      • the-yoneda-lemma
      • topoi
      • types-and-functions
      • yoneda-embedding
    • clean-code
      • boundaries
      • classes
      • clean-code
      • comments
      • concurrency
      • emergence
      • error-handling
      • formatting
      • functions
      • junit-internals
      • meaningful-names
      • objects-and-data-structures
      • refactoring-serialdate
      • smells-and-heuristics
      • successive-refinement
      • systems
      • unit-tests
    • compiling-to-assembly-from-scratch
      • Abstract Syntax Tree
      • Arrays and Heap Allocation
      • Dynamic Typing
      • First Pass: The Parser
      • Garbage Collection
      • High-level Compiler Overview
      • Introduction
      • Introduction to ARM Assembly Programming
      • Introduction to Parser Combinators
      • Introduction to Part II
      • Second Pass: Code Generation
      • Static Type Checking and Inference
      • Typescript Basics
      • Visitor Pattern
    • computer-networking-a-top-down-approach
      • Application Layer
      • Computer Networks and the Internet
      • Security in Computer Networks
      • The Link Layer and LANs
      • The Network Layer: Control Plane
      • The Network Layer: Data Plane
      • Transport Layer
      • Wireless and Mobile Networks
    • computer-networks-a-systems-approach
      • Advanced Internetworking
      • Applications
      • Congestion Control
      • Direct Links
      • End-to-End Data
      • End-to-End Protocols
      • Foundation
      • Internetworking
      • Network Security
    • crafting-interpreters
      • A Map of the Territory
      • A Virtual Machine
      • Calls and Functions
      • Chunks of Bytecode
      • Classes
      • Classes and Instances
      • Closures
      • Compiling Expressions
      • Control Flow
      • Evaluating Expressions
      • Functions
      • Garbage Collection
      • Global Variables
      • Hash Tables
      • Inheritance
      • Introduction
      • Jumping Back and Forth
      • Local Variables
      • Methods and Initializers
      • Optimization
      • Parsing Expressions
      • Representing Code
      • Resolving and Binding
      • Scanning
      • Scanning on Demand
      • Statements and State
      • Strings
      • Superclasses
      • The Lox Language
      • Types of Values
    • cses
      • additional-topics
      • advanced-graph-algorithms
      • algorithm-design-topics
      • data-structures
      • dynamic-programming
      • efficiency
      • geometry
      • graph-algorithms
      • introduction
      • mathematics
      • programming-techniques
      • range-queries
      • sorting-and-searching
      • string-algorithms
      • tree-algorithms
    • database-design-and-implementation
      • Database Systems
      • Disk and File Management
      • Efficient Buffer Utilization
      • Indexing
      • JDBC
      • JDBC interfaces
      • Materialization and Sorting
      • Memory Management
      • Metadata Management
      • Parsing
      • Planning
      • Query Optimization
      • Query Processing
      • Record Management
      • Transaction Management
    • database-internals
      • Anti-Entropy and Dissemination
      • B-Tree Basics
      • B-Tree Variants
      • Consensus
      • Distributed Systems Introduction and Overview
      • Distributed Transactions
      • Failure Detection
      • File Formats
      • Implementing B-Trees
      • Leader Election
      • Log-Structured Storage
      • Replication and Consistency
      • Storage Engines Introduction and Overview
      • Transaction Processing and Recovery
    • design-patterns-elements-of-reusable-object-oriented-software
      • a-case-study-designing-a-document-editor
      • behavioral-patterns
      • conclusion
      • creational-patterns
      • introduction
      • structural-patterns
    • designing-data-intensive-applications
      • batch-processing
      • consistency-and-consensus
      • data-models-and-query-languages
      • distributed-systems-trouble
      • encoding-and-evolution
      • partitioning
      • reliable-scalable-and-maintainable-applications
      • replication
      • storage-and-retrieval
      • stream-processing
      • the-future-of-data-systems
      • transactions
    • effective-rust
      • Asynchronous Rust
      • Beyond Standard Rust
      • Concepts
      • Dependencies
      • Introduction
      • Tooling
      • Types
    • effective-typescript
      • getting-to-know-typescript
      • Migrating to Typescript
      • Type Design
      • Type Inference
      • Types Declarations and @types
      • Typescript's Type System
      • Working with any
      • Writing and Running Your Code
    • efficient-mysql-performance
      • Access Patterns
      • Data
      • Indexes and Indexing
      • Query Response Time
      • Replication Lag
      • Server Metrics
      • Sharding
      • Transactions
    • engineering-a-compiler
      • Code Shape
      • Data-Flow Analysis
      • Implementing Procedures
      • Instruction Scheduling
      • Instruction Selection
      • Intermediate Representations
      • Introduction to Optimization
      • Overview of Compilation
      • Parsers
      • Register Allocation
      • Runtime Optimization
      • Scalar Optimization
      • Scanners
      • Syntax-Driven Translation
    • game-programming-patterns
      • bytecode
      • command
      • component
      • data-locality
      • dirty-flag
      • double-buffer
      • event-queue
      • flyweight
      • game-loop
      • object-pool
      • observer
      • prototype
      • service-locator
      • singleton
      • spatial-partition
      • state
      • subclass-sandbox
      • type-object
      • update-method
    • high-performance-browser-networking
      • brief-history-of-http
      • building-blocks-of-tcp
      • building-blocks-of-udp
      • http1x
      • http2
      • introduction-to-wireless-networks
      • mobile-networks
      • optimizing-application-delivery
      • optimizing-for-mobile-networks
      • primer-on-browser-networking
      • primer-on-latency-and-bandwidth
      • primer-on-web-performance
      • server-sent-events-sse
      • transport-layer-security-tls
      • webrtc
      • websocket
      • wifi
      • xmlhttprequest
    • high-performance-mysql
      • Backup and Recovery
      • Compliance with MySQL
      • Indexing for High Performance
      • Monitoring in a Reliability Engineering World
      • MySQL Architecture
      • MySQL in the Cloud
      • MySQL on Kubernetes
      • Operating System and Hardware Optimization
      • Optimizing Server Settings
      • Performance Schema
      • Query Performance Optimization
      • Replication
      • Scaling MySQL
      • Schema Design and Management
      • Upgrading MySQL
    • how-linux-works
      • a-brief-survey-of-the-linux-desktop
      • a-closer-look-at-processes-and-resource-utilization
      • basic-commands-directory-hierarchy
      • building-on-the-basics
      • development-tools
      • devices
      • disks-and-filesystems
      • how-the-linux-kernel-boots
      • how-user-space-starts
      • introduction-to-compiling-software-from-c-source-code
      • introduction-to-shell-scripts
      • moving-files-across-the-network
      • network-applications-and-services
      • system-configuration-logging-system-time-batch-jobs-and-users
      • the-big-picture
      • understanding-your-network-and-its-configuration
      • user-environments
    • how-to-solve-it
      • how-to-solve-it-chapter-1
    • introduction-to-probability
      • Conditional expectation
      • Conditional probability
      • Continuous random variables
      • Expectation
      • Inequalities and limit theorems
      • Joint distributions
      • Markov chain Monte Carlo
      • Markov chains
      • Moments
      • Poisson processes
      • Probability and counting
      • Random variables and their distributions
      • Transformations
    • introduction-to-probability-for-computing
      • A Little Bit of Queueing Theory
      • Applications of Tail Bounds: Confidence Intervals: Balls and Bins
      • Bayesian Statistical Inference
      • Before We Start: Some Mathematical Basics
      • Classical Statistical Inference
      • Common Discrete Random Variables
      • Continuous Random Variables: Joint Distributions
      • Continuous Random Variables: Single Distribution
      • Discrete-Time Markov Chains: Finite-State
      • Discrete-Time Markov Chains: Infinite-State
      • Ergodicity for Finite-State Discrete-Time Markov Chains
      • Estimators for Mean and Variance
      • Event-Driven Simulation
      • Expectation
      • Generating Random Variables for Simulation
      • Hashing Algorithms
      • Heavy Tails: The Distributions of Computing
      • Laplace Transforms
      • Las Vegas Randomized Algorithms
      • Monte Carlo Randomized Algorithms
      • Normal Distribution
      • Preface and Contents
      • Primality Testing
      • Probability on Events
      • Tail Bounds
      • The Poisson Process
      • Variance, Higher Moments, and Random Sums
      • z-Transforms
    • kill-it-with-fire
      • Breaking Changes
      • Building and Protecting Momentum
      • Cannibal Code
      • Coming in Midstream
      • Design as Destiny
      • Evaluating Your Architecture
      • Future Proofing
      • How to Finish
      • Time is a Flat Circle
      • Why is it Hard
    • kubernetes-in-action
      • Accessing pod metadata and other resources from applications
      • Advanced scheduling
      • Automatic scaling of pods and cluster nodes
      • Best practices for developing apps
      • ConfigMaps and Secrets: configuring applications
      • Deployments: updating applications declaratively
      • Extending Kubernetes
      • First steps with Docker and Kubernetes
      • Introducing Kubernetes
      • Managing pods’ computational resources
      • Pods: running containers in Kubernetes
      • Replication and other controllers: deploying managed pods
      • Securing cluster nodes and the network
      • Securing the Kubernetes API server
      • Services: enabling clients to discover and talk to pods
      • StatefulSets: deploying replicated stateful applications
      • Understanding Kubernetes internals
      • Volumes: attaching disk storage to containers
    • learn-you-a-haskell
      • learn-you-a-haskell-chapter-1
      • learn-you-a-haskell-chapter-2
      • learn-you-a-haskell-chapter-3
      • learn-you-a-haskell-chapter-4
      • learn-you-a-haskell-chapter-5
      • learn-you-a-haskell-chapter-6
      • learn-you-a-haskell-chapter-7
      • learn-you-a-haskell-chapter-8
      • learn-you-a-haskell-chapter-9
      • learn-you-a-haskell-chapter-10
      • learn-you-a-haskell-chapter-11
      • learn-you-a-haskell-chapter-12
      • learn-you-a-haskell-chapter-13
      • learn-you-a-haskell-chapter-14
    • operating-systems-three-easy-pieces
      • a-dialogue-on-concurrency
      • a-dialogue-on-distribution
      • a-dialogue-on-memory-virtualization
      • a-dialogue-on-persistence
      • a-dialogue-on-the-book
      • a-dialogue-on-virtualization
      • beyond-physical-memory-mechanisms
      • beyond-physical-memory-policies
      • common-concurrency-problems
      • complete-virtual-memory-systems
      • concurrency-an-introduction
      • condition-variables
      • crash-consistency-fsck-and-journaling
      • data-integrity-and-protection
      • distributed-systems
      • event-based-concurrency-advanced
      • file-system-implementation
      • flash-based-ssds
      • free-space-management
      • hard-disk-drives
      • interlude-files-and-directories
      • interlude-memory-api
      • interlude-process-api
      • interlude-thread-api
      • introduction-to-operating-systems
      • io-devices
      • locality-and-the-fast-file-system
      • lock-based-concurrent-data-structures
      • locks
      • log-structured-file-systems
      • mechanism-address-translation
      • mechanism-limited-direct-execution
      • multiprocessor-scheduling-advanced
      • paging-faster-translations-tlbs
      • paging-introduction
      • paging-smaller-tables
      • redundant-arrays-of-inexpensive-disks-raids
      • scheduling-introduction
      • scheduling-proportional-share
      • scheduling-the-multi-level-feedback-queue
      • segmentation
      • semaphores
      • summary-dialogue-on-concurrency
      • summary-dialogue-on-cpu-virtualization
      • summary-dialogue-on-memory-virtualization
      • summary-dialogue-on-persistence
      • suns-network-file-system-nfs
      • the-abstraction-address-spaces
      • the-abstraction-the-process
      • the-andrew-file-system-afs
    • perfbook
      • Advanced Synchronization
      • Advanced Synchronization: Memory Ordering
      • Conflicting Visions of the Future
      • Counting
      • Data Ownership
      • Data Structures
      • Deferred Processing
      • Ease of Use
      • Formal Verification
      • Hardware and its Habits
      • How To Use This Book
      • Locking
      • Partitioning and Synchronization Design
      • Putting It All Together
      • Tools of the Trade
      • Validation
    • postgres-internals
      • B-tree
      • BRIN
      • Buffer Cache
      • Freezing
      • GIN
      • GiST
      • Hash
      • Hashing
      • Index Access Methods
      • Index Scans
      • Introduction
      • Isolation
      • Locks on Memory Structures
      • Miscellaneous Locks
      • Nested Loop
      • Page Pruning and HOT Updates
      • Pages and Tuples
      • Query Execution Stages
      • Rebuilding Tables and Indexes
      • Relation-Level Locks
      • Row-Level Locks
      • Snapshots
      • Sorting and Merging
      • SP-GiST
      • Statistics
      • Table Access Methods
      • Vacuum and Autovacuum
      • WAL Modes
      • Write-Ahead Log
    • probabilistic-data-structures-and-algorithms-for-big-data-applications
      • cardinality
      • frequency
      • hashing
      • membership
      • rank
      • similarity
    • programming-clojure
      • Building an Application
      • Exploring Clojure
      • Functional Programming
      • Getting Started
      • Java Interop
      • Macros
      • Multimethods
      • Protocols and Datatypes
      • Specifications
      • State and Concurrency
      • Unifying Data with Sequences
    • purely-functional-data-structures
      • amortization-and-persistence-via-lazy-evaluation
      • data-structural-bootstrapping
      • eliminating-amortization
      • fundamentals-of-amortization
      • implicit-recursive-slowdown
      • introduction
      • lazy-evaluation
      • lazy-rebuilding
      • numerical-representations
      • persistence
      • some-familiar-data-structures-in-a-functional-setting
    • randomized-algorithms
      • Algebraic Techniques
      • Approximate Counting
      • Data Structures
      • Game-Theoretic Techniques
      • Geometric Algorithms and Linear Programming
      • Graph Algorithms
      • Introduction
      • Markov Chains and Random Walks
      • Moments and Deviations
      • Number Theory and Algebra
      • Online Algorithms
      • Parallel and Distributed Algorithms
      • Tail Inequalities
      • The Probabilistic Method
    • real-world-cryptography
      • asymmetric-encryption-and-hybrid-encryption
      • authenticated-encryption
      • crypto-as-in-cryptocurrency
      • end-to-end-encryption
      • hardware-cryptography
      • hash-functions
      • introduction
      • is-this-it-next-generation-cryptography
      • key-exchanges
      • message-authentication-codes
      • post-quantum-cryptography
      • randomness-and-secrets
      • secure-transport
      • signatures-and-zero-knowledge-proofs
      • user-authentication
      • where-cryptography-fails-and-final-words
    • rust-for-rustaceans
      • Asynchronous Programming
      • Concurrency and Parallelism
      • Designing Interfaces
      • Error Handling
      • Foreign Function Interfaces
      • Foundations
      • Macros
      • Project Structure
      • Rust Without the Standard Library
      • Testing
      • The Rust Ecosystem
      • Types
      • Unsafe Code
    • serious-cryptography
      • Authenticated Encryption
      • Block Ciphers
      • Cryptocurrency Cryptography
      • Cryptographic Security
      • Diffie–Hellman
      • Elliptic Curves
      • Encryption
      • Hard Problems
      • Hash Functions
      • Keyed Hashing
      • Quantum and Post-Quantum
      • Randomness
      • RSA
      • Stream Ciphers
      • TLS 255
    • sql-performance-explained
      • anatomy-of-an-index
      • clustering-data
      • execution-plans
      • modifying-data
      • partial-results
      • performance-and-scalability
      • sorting-and-grouping
      • the-join-operation
      • the-where-clause
    • structured-computer-organization
      • Computer systems
      • Introduction
      • Parallel computer architectures
      • Reading list and bibliography
      • The Assembly Language Level
      • The digital logic level
      • The Instruction Set
      • The Microarchitecture Level
      • The Operating System
    • system-design-interview-an-insiders-guide
      • chapter 2 back-of-the-envelope estimation
      • chapter 3 a framework for system design interviews
      • chapter 4 design a rate limiter
      • chapter 5 design consistent hashing
      • chapter 6 design a key-value store
      • chapter 7 design a unique id generator in distributed systems
      • chapter 8 design a url shortener
      • chapter 9 design a web crawler
      • chapter 10 design a notification system
      • chapter 11 design a news feed system
      • chapter 12 design a chat system
      • chapter 13 design a search autocomplete system
      • chapter 14 design youtube
      • chapter 15 design google drive
      • chapter 16 the learning continues
      • Scale from Zero to Millions of Users
    • system-design-interview-an-insiders-guide-volume-2
      • Ad Click Event Aggregation
      • Digital Wallet
      • Distributed Email Service
      • Distributed Message Queue
      • Google Maps
      • Hotel Reservation System
      • Metrics Monitoring and Alerting System
      • Nearby Friends
      • Payment System
      • Proximity Service
      • Real-time Gaming Leaderboard
      • S3-like Object Storage
      • Stock Exchange
      • The Learning Continues
    • systems-performance-enterprise-and-the-cloud
      • applications
      • benchmarking
      • bpf
      • case-study
      • cloud-computing
      • cpus
      • disks
      • file-systems
      • ftrace
      • introduction
      • memory
      • methodologies
      • network
      • observability-tools
      • operating-systems
      • perf
    • the-algorithm-design-manual
      • A Catalog of Algorithmic Problems
      • Algorithm Analysis
      • Combinatorial Problems
      • Combinatorial Search
      • Computational Geometry
      • Data Structures
      • Data Structures Catalog
      • Dealing with Hard Problems
      • Divide and Conquer
      • Dynamic Programming
      • Graph Problems: NP-Hard
      • Graph Problems: Polynomial Time
      • Graph Traversal
      • Hashing and Randomized Algorithms
      • How to Design Algorithms
      • Introduction to Algorithm Design
      • NP-Completeness
      • Numerical Problems
      • Set and String Problems
      • Sorting
      • Weighted Graph Algorithms
    • the-anatomy-of-a-high-performance-microprocessor
      • A Microarchitecture Case Study
      • Microprocessors, Platforms and Systems
      • Platform Memory Technology
      • Platform Optimization Techniques and Directions
      • Technology Components of Platform Architecture
      • The K6 3D Microarchitecture
    • the-art-of-multiprocessor-programming
      • Barriers
      • Concurrent hashing and natural parallelism
      • Concurrent Objects
      • Counting, sorting, and distributed coordination
      • Data parallelism
      • Foundations of shared memory
      • Introduction
      • Linked lists: the role of locking
      • Monitors and blocking synchronization
      • Mutual Exclusion
      • Optimism and manual memory management
      • Priority Queues
      • Queues, memory management, and the ABA problem
      • Scheduling and work distribution
      • Skiplists and balanced search
      • Spin locks and contention
      • Stacks and elimination
      • The relative power of primitive synchronization operations
      • Transactional programming
      • University of consensus
    • the-art-of-postgresql
      • a-small-application
      • an-interview-with-alvaro-hernandez-tortosa
      • an-interview-with-craig-kersteins
      • an-interview-with-gregoire-hubert
      • an-interview-with-kris-jenkins
      • an-interview-with-markus-winand
      • an-interview-with-yohann-gabory
      • another-small-application
      • auditing-changes-with-hstore
      • batch-update-moma-collection
      • business-logic
      • computing-and-caching-in-sql
      • counting-distinct-users-with-hyperloglog
      • denormalization
      • denormalized-data-types
      • denormalizing-tags-with-intarray
      • geolocation-with-postgresql
      • get-some-data
      • getting-ready-to-read-this-book
      • group-by-having-with-union-all
      • how-far-is-the-nearest-pub
      • indexing-strategy
      • insert-update-delete
      • isolation-and-locking
      • lastfm-million-song-data
      • listen-and-notify
      • modelization-anti-patterns
      • normalization
      • not-only-sql
      • object-relational-mapping
      • order-by-limit-no-offset
      • postgresql-data-types
      • postgresql-extensions
      • practical-use-case-geonames
      • queries-dml-ddl-tcl-dcl
      • select-from-where
      • serialization-and-deserialization
      • software-architecture
      • some-relational-theory
      • sql
      • sql-is-code
      • structured-query-language
      • the-most-popular-pub-names
      • the-sql-repl----an-interactive-setup
      • tooling-for-database-modeling
      • triggers
      • understanding-nulls
      • understanding-relations-and-joins
      • understanding-window-functions
      • using-trigrams-for-typos
      • whats-a-postgresql-extension
    • the-c-programming-language
      • the-c-programming-language-chapter-1
      • the-c-programming-language-chapter-2
      • the-c-programming-language-chapter-3
      • the-c-programming-language-chapter-4
      • the-c-programming-language-chapter-5
      • the-c-programming-language-chapter-6
      • the-c-programming-language-chapter-7
      • the-c-programming-language-chapter-8
    • the-daily-stoic
      • february
      • january
    • the-dynamodb-book
      • additional-strategies
      • Advanced Concepts
      • building-a-session-store
      • building-an-e-commerce-application
      • building-big-time-deals
      • core-concepts-in-dynamodb
      • data-modeling-examples
      • expressions
      • from-modeling-to-implementation
      • handling-migrations-in-our-github-example
      • how-to-approach-data-modeling-in-dynamodb
      • recreating-githubs-backend
      • strategies-for-filtering
      • strategies-for-many-to-many-relationships
      • strategies-for-migrations
      • strategies-for-one-to-many-relationships
      • strategies-for-sorting
      • the-importance-of-strategies
      • the-three-api-action-types
      • the-what-why-and-when-of-single-table-design-in-dynamodb
      • using-the-dynamodb-api
      • what-is-dynamodb
    • the-linux-programming-interface
      • access-control-lists
      • advanced-features-of-shared-libraries
      • alternative-io-models
      • capabilities
      • daemons
      • directories-and-links
      • extended-attributes
      • file-attributes
      • file-io-buffering
      • file-io-further-details
      • file-io-the-universal-io-model
      • file-locking
      • file-systems
      • fundamental-concepts
      • fundamentals-of-shared-libraries
      • history-and-standards
      • interprocess-communication-overview
      • introduction-to-posix-ipc
      • introduction-to-system-v-ipc
      • login-accounting
      • memory-allocation
      • memory-mappings
      • monitoring-child-processes
      • monitoring-file-events-with-inotify
      • pipes-and-fifos
      • posix-message-queues
      • posix-semaphores
      • posix-shared-memory
      • preface
      • process-creation
      • process-creation-and-program-execution-in-more-detail
      • process-credentials
      • process-groups-sessions-and-job-control
      • process-priorities-and-scheduling
      • process-resources
      • process-termination
      • processes
      • program-execution
      • pseudoterminals
      • retrieving-system-and-process-information
      • signals-advanced-features
      • signals-fundamental-concepts
      • signals-signal-handlers
      • sockets-advanced-topics
      • sockets-fundamentals-of-tcpip-networks
      • sockets-internet-domains
      • sockets-introduction
      • sockets-server-design
      • sockets-unix-domain
      • system-limits-and-options
      • system-programming-concepts
      • system-v-message-queues
      • system-v-semaphores
      • system-v-shared-memory
      • terminals
      • threads-further-details
      • threads-introduction
      • threads-thread-cancellation
      • threads-thread-safety-and-per-thread-storage
      • threads-thread-synchronization
      • timers-and-sleeping
      • times-and-dates
      • users-and-groups
      • virtual-memory-operations
      • writing-secure-privileged-programs
    • the-little-book-of-semaphores
      • basic-synchronization-patterns
      • classical-synchronization-problems
      • introduction
      • less-classical-synchronization-problems
      • not-remotely-classical-problems
      • not-so-classical-problems
      • semaphores
      • synchronization-in-c
      • synchronization-in-python
    • the-mythical-man-month
      • 'No Silver Bullet' Refined
      • Aristocracy, Democracy, and System Design
      • Calling the Shot
      • Fifty Years of Wonder, Excitement, and Joy
      • Hatching a Catastrophe
      • No Silver Bullet—Essence and Accident in Software Engineering
      • Passing the Word
      • Plan to Throw One Away
      • Propositions of The Mythical Man-Month: True or False?
      • Sharp Tools
      • Ten Pounds in a Five-Pound Sack
      • The Documentary Hypothesis
      • The Mythical Man-Month
      • The Mythical Man-Month after 20 Years
      • The Other Face
      • The Second-System Effect
      • The Surgical Team
      • The Tar Pit
      • The Whole and the Parts
      • Why Did the Tower of Babel Fail?
    • transaction-processing
      • Advanced Locking Protocols
      • B-Tree Structure Modifications
      • B-Tree Traversals
      • Bulk Operations on B-Trees
      • Concurrency Control by Versioning
      • Distributed Transactions
      • Lock-Based Concurrency Control
      • Logging and Buffering
      • Online Index Construction and Maintenance
      • Operations on the Physical Database
      • Processing of Write-Intensive Transactions
      • Transaction Processing
      • Transaction Rollback and Restart Recovery
      • Transactional Isolation
      • Transactions in Page-Server Systems
      • Transactions on the Logical Database
    • understanding-software-dynamics
      • Aggregate Measures
      • CPU and Memory Interaction
      • Dashboards
      • Disk and Network Database Interaction
      • Executing Slowly
      • Executing Too Much
      • KUtrace: Display of Software Dynamics
      • KUtrace: Goals, Design, Implementation
      • KUtrace: Linux Kernel Patches
      • KUtrace: Linux Loadable Module
      • KUtrace: Postprocessing
      • KUtrace: User-Mode Runtime Control
      • Logging
      • Measurement
      • Measuring CPUs
      • Measuring Disk/SSD
      • Measuring Memory
      • Measuring Networks
      • My Program Is Too Slow
      • Observation Tool Design Principles
      • Other Existing Tools
      • Recap
      • Traces
      • Waiting for CPU
      • Waiting for Disk
      • Waiting for Locks
      • Waiting for Memory
      • Waiting for Network
      • Waiting for Queues
      • Waiting for Time
      • What to Look For
    • unix-and-linux-system-administration-handbook
      • access-control-and-rootly-powers
      • booting-and-system-management-daemons
      • cloud-computing
      • configuration-management
      • containers
      • continuous-integration-and-delivery
      • data-center-basics
      • dns-the-domain-name-system
      • drivers-and-the-kernel
      • electronic-mail
      • ip-routing
      • logging
      • methodology-policy-and-politics
      • monitoring
      • performance-analysis
      • physical-networking
      • printing
      • process-control
      • scripting-and-the-shell
      • security
      • single-sign-on
      • smb
      • software-installation-and-management
      • storage
      • tcpip-networking
      • the-filesystem
      • the-network-file-system
      • user-management
      • virtualization
      • web-hosting
      • where-to-start
    • _books
    • atomic-habits
    • between-the-world-and-me
    • black-swan
    • born-a-crime
    • clean-ruby
    • crossing-the-chasm
    • deep-work
    • educated
    • grit
    • inside-the-tornado
    • list
    • long-walk-to-freedom
    • mans-search-for-meaning
    • meditations
    • radical-candor
    • refactoring
    • street-fighting-mathematics
    • The 7 Habits of Highly Effective People
    • The Art of War
    • The Bitcoin Standard
    • The Rust Programming Language
    • the-choice
    • the-little-mler
    • the-new-economics
    • Zero to One
  • business
    • steveys-tech-talk
      • All About Big Tech Interviews
      • How to Fire Your Boss
      • How to Get Yourself Promoted
      • How to Motivate People
      • Tips for New Managers
    • Ask Me This Instead
    • Wisdom
  • compilers
    • crafting-interpreters
      • 1_introduction
        • Chapter 1
      • 2_map_of_territory
        • Compilers/Crafting-Interpreters/2_Map_Of_Territory
      • 3_lox_language
        • Compilers/Crafting-Interpreters/3_Lox_Language
      • 4_scanning
        • crafting-interpreters-chapter-4
    • interpreter-go
      • ch_1
        • notes
    • optimizations
      • Compiler Optimizations
  • computer-architecture
    • performance-aware-programming
      • 0-welcome
      • 1-waste
      • 2-instructions-per-clock
      • 3-single-instruction-multiple-data
      • 4-caching
      • 5-multithreading
      • 6-python-revisisted
    • How Logic Gates Make Computers
  • courses
    • algorithmic-game-theory
      • Algorithmic Mechanism Design
      • Best-Case and Strong Nash Equilibria
      • Best-Response Dynamics
      • Beyond Quasi-Linearity
      • Hierarchy of Equilibrium Concepts
      • Introduction
      • Kidney Exchange Stable Matching
      • Mechanism Design Basics
      • Mixed NE and PPAD-Completeness
      • Myerson's Lemma
      • Network Over-Provisioning
      • No-Regret Dynamics
      • Pure NE and PLS-Completeness
      • Revenue-Maximizing Auctions
      • Selfish Routing and the POA
      • Simple Near-Optimal Auctions
      • Smooth Games
      • Spectrum Auctions
      • Swap Regret; Minimax
      • VCG Mechanism
    • algorithms-for-big-data
      • Alon's JL lower bound, beyond worst case analysis: suprema of gaussian processes, Gordon's theorem
      • amnesic dynamic programming (approximate distance to monotonicity)
      • analysis of ℓp estimation algorithm via max-stability, deterministic point query via incoherent matrices
      • approximate matrix multiplication with Frobenius error via sampling / JL, matrix median trick, subspace embeddings
      • communication complexity (indexing, gap hamming) + application to median and F0 lower bounds
      • competitive paging, cache-oblivious algorithms: matrix multiplication, self-organizing linked list, static B-tree, lazy funnelsort
      • CountMin sketch, point query, heavy hitters, sparse approximation
      • CountSketch, ℓ0 sampling, graph sketching
      • distinct elements, k-wise independence, geometric subsampling of streams
      • external memory model: linked list, matrix multiplication, B-tree, buffered repository tree, sorting
      • Khintchine, decoupling, Hanson-Wright, proof of distributional JL lemma
      • Krahmer-Ward proof, Iterative Hard Thresholding
      • L1 & L1 recovery, RIP1, unbalanced expanders, Sequential Sparse Matching Pursuit
      • linear least squares via subspace embeddings, leverage score sampling, non-commutative Khintchine, oblivious subspace embeddings
      • logistics, course topics, basic tail bounds (Markov, Chebyshev, Chernoff, Bernstein), Morris' algorithm
      • low-rank approximation, column-based matrix reconstruction, k-means, compressed sensing
      • MapReduce: TeraSort, minimum spanning tree, triangle counting
      • matrix completion
      • necessity of randomized/approximate guarantees, linear sketching, AMS sketch, p-stable sketch 0<p<2
      • oblivious subspace embeddings, faster iterative regression, sketch-and-solve regression
      • ORS theorem (distributional JL implies Gordon's theorem), sparse JL
      • p-stable sketch analysis, Nisan's PRG, high ℓp norms (p>2) via max-stability
      • randomized and approximate F0 lower bounds, disjointness, Fp lower bound, dimensionality reduction (JL lemma)
      • RIP and connection to incoherence, basis pursuit, Krahmer-Ward theorem
      • sparse JL proof wrap-up, Fast JL Transform, approximate nearest neighbor
    • an-introduction-to-computer-networks
      • Abstract Sliding Windows
      • Advanced Ethernet
      • An Overview of Networks
      • Bibliography
      • Border Gateway Protocol (BGP)
      • Dynamics of TCP
      • Ethernet Basics
      • Exercise-Numbering Conversion Tables
      • Further Dynamics of TCP
      • IPv4
      • IPv4 Companion Protocols
      • IPv6
      • IPv6 Additional Features
      • Large-Scale IP Routing
      • Links
      • Mininet
      • Network Management and SNMP
      • Network Simulations: ns-2
      • Newer TCP Implementations
      • Other LANs
      • Packets
      • Preface
      • Public-Key Encryption
      • Quality of Service
      • Queuing and Scheduling
      • Routing-Update Algorithms
      • Security
      • Selected Solutions
      • SNMP versions 2 and 3
      • TCP Issues and Alternatives
      • TCP Reno and Congestion Management
      • TCP Transport Basics
      • The ns-3 Network Simulator
      • Token Bucket Rate Limiting
      • UDP Transport
      • Wireless LANs
    • cs-6120-advanced-compilers
      • Lesson 1 Welcome and Overview
      • Lesson 2: Introduction To Bril
      • Lesson 2: Representing Programs
      • Lesson 3: Local Optimization & Dead Code Elimination
      • Lesson 3: Local Value Numbering
      • Lesson 4: Data Flow
      • Lesson 4: Implementation Task
      • Lesson 5: Global Analysis & Optimization
      • Lesson 5: Static Single Assignment
      • Lesson 6: Introduction To Llvm
      • Lesson 6: Writing An Llvm Pass
      • Lesson 7: Interprocedural Analysis
      • Lesson 8: Interprocedural Analysis
      • Lesson 9: Alias Analysis
      • Lesson 10: Memory Management
      • Lesson 11: Dynamic Compilers
      • Lesson 11: Tracing Via Speculation
      • Lesson 12: Program Synthesis
      • Lesson 13: Concurrency & Parallelism
    • database-systems
      • Advanced SQL
      • Buffer Pools
      • Concurrency Control Theory
      • Course Introduction and the Relational Model
      • Crash Recovery Algorithms
      • Database Storage I
      • Database Storage II
      • Distributed OLAP Database Systems
      • Distributed OLTP Database Systems
      • Final Review + Other Systems
      • Guest Speaker Shasank Chavan Oracle In-Memory Databases
      • Hash Tables
      • Index Concurrency Control
      • Introduction to Distributed Databases
      • Joins Algorithms
      • Logging Protocols + Schemes
      • Multi-Version Concurrency Control
      • Query Execution I
      • Query Execution II
      • Query Planning & Optimization I
      • Query Planning & Optimization II
      • Sorting + Aggregations
      • Timestamp Ordering Concurrency Control
      • Trees Indexes I
      • Trees Indexes II
      • Two-Phase Locking Concurrency Control
    • finance-theory-i
      • Capital Budgeting II & Efficient Markets I
      • Efficient Markets II
      • Efficient Markets III & Course Summary
      • Equities
      • Fixed-Income Securities II
      • Fixed-Income Securities III
      • Fixed-Income Securities IV
      • Forward and Futures Contracts I
      • Forward and Futures Contracts II & Options I
      • Introduction and Course Overview
      • Midterm Exam
      • Options II
      • Options III & Risk and Return I
      • Portfolio Theory II
      • Portfolio Theory III & The CAPM and APT I
      • Present Value Relations I
      • Present Value Relations II
      • Present Value Relations III & Fixed-Income Securities I
      • Risk and Return II & Portfolio Theory I
      • The CAPM and APT II
      • The CAPM and APT III & Capital Budgeting I
    • great-ideas-in-theoretical-computer-science
      • Circuits and finite automata
      • Complexity
      • Cryptographic protocols
      • Derandomization, cryptography double feature
      • Interactive proofs, machine learning
      • Introduction
      • Learning, Chomsky, RSA, quantum
      • Logic
      • Minds and machines
      • NP-completeness
      • NP-completeness in practice
      • P and NP
      • Polynomial time
      • Private-key cryptography
      • Probabilistic complexity classes
      • Probably Approximately Correct (PAC) learning
      • Public-key cryptography
      • Quantum algorithms
      • Quantum computing
      • Randomness
      • Reducibility and Gödel
      • Space complexity and more
      • Turing machines
    • introduction-to-algorithms
      • ASP & Johnson's Algorithm
      • Bellman-Ford
      • Binary Heaps
      • Binary Trees, Part 1
      • Binary Trees, Part 2: AVL
      • Breadth-First Search
      • Complexity
      • Course Review
      • Data Structures
      • Depth-First Search
      • Dijkstra's Algorithm
      • Dynamic Programming, Part 1: SRBOT, Fib, DAGs, Bowling
      • Dynamic Programming, Part 2: LCS, LIS, Coins
      • Dynamic Programming, Part 3
      • Dynamic Programming, Part 4: Rods, Subsetsums, Pseudopolynomial
      • Hashing
      • Introduction
      • Linear Sorting
      • Sorting
      • Weighted Shortest Paths
    • lectures-notes-on-game-theory
      • Auctions
      • Better response dynamics and potential games
      • Extensive form games with chance moves and imperfect information
      • Finite extensive form games with perfect information
      • Knowledge and belief
      • Repeated games
      • Social choice
      • Social learning
      • Strategic form games
      • What is a Game?
    • machine-learning
      • Approximation, Estimation Error & ERM
      • Back Propagation and Improving Neural Networks
      • Data Splits, Models & Cross Validation
      • Debugging and Diagnostics
      • Debugging ML Models and Error Analysis
      • Decision Trees and Ensemble Methods
      • EM Algorithm & Factor Analysis
      • Expectation Maximization Algorithms
      • GDA & Naive Bayes
      • Independent Component Analysis and Reinforcement Learning
      • Introduction
      • Introduction to Neural Networks
      • Kernels
      • Linear Regression and Gradient Descent
      • Locally Weighted and Logicistic Regression
      • MDPs & Model Simulation
      • MDPs & Value/Policy Iteration
      • Perceptron & Generalized Linear Model
      • Reward Model and Linear Dynamical System
      • Support Vector Machines
    • mit-distributed-systems-6824
      • Bitcoin
      • Blockstack
      • Cache Consistency: Frangipani
      • Cache Consistency: Memcached At Facebook
      • Cloud Replicated Db, Aurora
      • Cops, Causal Consistency
      • Distributed Transactions
      • Fault Tolerance: Raft-1
      • Fault Tolerance: Raft-2
      • Fork Consistency, Certificate Transparency
      • Gfs
      • Go, Threads, And Raft
      • Introduction
      • More Replication, Craq
      • Optimistic Concurrency Control
      • Primary Backup Replication
      • Rpc And Threads
      • Spanner
      • Zookeeper
    • notes-on-discrete-mathematics
      • A Connecticut class in King Arthur’s court
      • A glimpse of cryptography
      • Combinatorial probability
      • Counting subsets
      • Fibonacci numbers
      • Finding the optimum
      • Graph coloring
      • Graphs
      • Induction
      • Integers, divisors, and primes
      • Introduction
      • Let us count!
      • Matchings in graphs
      • One-time pads
      • Pascal’s Triangle
      • Trees
    • performance-engineering-of-software-systems
      • Analysis of Multithreaded Algorithms
      • Assembly Language & Computer Architecture
      • Bentley Rules for Optimizing Work
      • Bit Hacks
      • C to Assembly
      • Cache-Oblivious Algorithms
      • Caching and Cache-Efficient Algorithms
      • Domain Specific Languages and Autotuning
      • Graph Optimization
      • High Performance in Dynamic Languages
      • Introduction and Matrix Multiplication
      • Leiserchess Codewalk
      • Measurement and Timing
      • Multicore Programming
      • Nondeterministic Parallel Programming
      • Parallel Storage Allocation
      • Races and Parallelism
      • Speculative Parallelism & Leiserchess
      • Storage Allocation
      • Synchronization Without Locks
      • The Cilk Runtime System
      • Tuning a TSP Algorithm
      • What Compilers Can and Cannot Do
    • randomized-algorithms
      • All-pairs shortest path
      • Balls and Bins
      • Bloom filters
      • Computational geometry II
      • Concentration Inequalities
      • Cuckoo Hashing
      • Fingerprinting
      • Game Tree Evaluation
      • Introduction; min-cut
      • Limited Independence
      • Markov Chains I
      • Markov Chains II; Closest Pair
      • Matrix concentration and graph sparsification
      • Maximum perfect matchings
      • Nearest Neighbor Search
      • Network coding
      • Online Bipartite Matching
      • Power of Two Choices
      • Quicksort
      • Randomized numerical linear algebra I
      • Randomized numerical linear algebra II
      • Randomized Rounding
      • Routing
      • Sampling, median-finding
      • Spectral sparsification of graphs
    • statistics-lecture-notes
      • Confidence intervals and power
      • Factorial Designs
      • Introduction to ANOVA
      • Nested Designs
      • Principles of experimental design
      • Test statistics and randomization distributions
      • Tests based on population models
    • the-modern-algorithmic-toolbox
      • Compressive sensing
      • Curse of Dimensionality
      • Fourier methods
      • Generalization
      • Graphs as matrices and the Laplacian of a graph
      • How PCA works
      • Introduction Consistent hashing.
      • Linear and convex programming
      • Low-rank matrix approximations
      • Markov Chains
      • Property-preserving lossy compression
      • Regularization
      • Reservoir sampling
      • Similarity Search
      • Spectral techniques
      • Tensor methods
      • Understanding Principal Component Analysis
    • theory-of-computation-lecture-notes
      • Closure of language classes under set operations
      • Declarative models of computation
      • Deterministic finite automata
      • Efficient solution of problems: The class P
      • Efficient verification of solutions: The class NP
      • Equivalence of models
      • Introduction
      • Proving problems are not solvable in a model of computation
      • String Theory
      • Turing machines
      • Undecidability
  • cryptography
    • History
    • How TLS Works
  • data-structures
    • Arrays
    • Big-o-complexity
    • HashTables
    • HyperLogLogs
    • Iteration Vs Recursion
    • Memory
    • Nodes
    • pointers
    • Singly Linked Lists
    • Time Complexity of Data Structures
  • databases
    • data-modeling
      • Redis Data Modeling
    • postgres
      • always-load-sorted-data
      • anomaly-detection-with-stats
      • avoid-indexes-on-columns-with-low-selectivity
      • brin-index
      • btree-index
      • cluster
      • coalesce
      • disable-constraints-and-indexes-during-bulk-loads
      • explain-and-analyze
      • formatting-timestamps
      • gin-index
      • hash-index
      • locking-select
      • make-indexes-invisible
      • partial-indexes
      • row-level-security
      • schedule-at-uneven-times
      • type-casting
      • unlogged-tables
      • update-only-what-needs-updating
      • use-hashing-to-reduce-disk-usage
      • vacuum
    • sql
      • effective-sql
      • email-registration
      • mysql-8
      • read-only-table-swap
      • setup-pgtap-and-pg-prove
      • setup-postgrest-dbmate-redoc
    • time-series
      • a-basic-time-series-database
  • deep-dives
    • active-record-vs-data-mapper
    • amd-vs-risc
    • arm-vs-risc
    • asynchronous-io
    • backend-web-app-security-vulnerabilities
    • common-assembly-instructions
    • cryptographic-library-selection
    • hashmap-design
    • intel-vs-amd
    • llvm-optimizations
    • optimizing-functional-languages
    • ParadeDB
    • tls
  • devops
    • adding-ssl-to-nginx
    • eBPF tools
    • Glances
    • hardening-linux
    • installing-caddy
    • load-testing-with-bombardier
    • running-a-github-actions-worker
    • you-might-not-need-redis
  • frontend
    • analyze-webpack-bundle-size
  • information-theory
    • Hamming Codes
  • interviews
    • design
      • cpp
        • reference
          • C++11
          • C++14
          • C++17
          • C++20
          • C++20/17/14/11
        • Avoiding Implicit Conversions
        • Concepts
        • Constexpr
        • How Does the Virtual Keyword Work? How Do Vtables Work?
        • Inline
        • Map Vs Unordered Map
        • Spaceship Operator
        • Structured Bindings
        • Variadic Templates
        • What Does nodiscard Do?
        • What is the Rule of 5?
      • trivia
        • ACLs
        • Async I/O in Linux
        • Cgroups
        • Debugging
        • diffie-hellman
        • driver-protocols
        • edns
        • faster-memory-allocation
        • ffast-math
        • fork
        • gil
        • How Do Caches Work on Your Computer?
        • How Does an X86 Computer Boot?
        • https
        • ipc
        • kernel-bypass
        • linux-hierarchy
        • locking
        • lru
        • lto
        • mac-address
        • madvise
        • memory-allocation
        • memory-speed
        • mkfifo
        • mmap
        • moesi
        • multicast
        • multiple-processes
        • named-pipes
        • network-bonding
        • numa
        • paging
        • port-vs-socket
        • process-vs-thread
        • processor-pinning
        • queueing-disciplines
        • read-vs-recv
        • scheduling
        • shell
        • simd
        • tcp-fast-open
        • tcp-vs-udp
        • threading-models
        • tlb
        • trap-vs-interrupt
        • vdso
        • virtual-memory
        • What is BGP? How Does it Work?
        • what-is-a-nic
      • airbnb
      • algo-questions
      • api-rate-limiter
      • bank-service
      • bare-metal-hardware
      • chat-service
      • clock-speeds
      • concurrent-median
      • cpp-trivia
      • dependency-manager
      • design-a-feed-of-top-companies
      • design-a-rate-limiter
      • design-a-syncing-file-server
      • design-an-atm
      • design-an-order-book
      • design-make
      • design-youtube
      • ecommerce-website
      • faster-indexes
      • file-storage-service
      • garbage-collection
      • google-behavioral
      • gossip-protocol
      • green-lights
      • hash-tables
      • heavy-hitters
      • hyperloglog
      • insert-delete-get-random-o-1
      • job-queue
      • key-value-store
      • market-maker
      • max-size-of-island-with-change
      • messaging-service
      • meta-system-design-questions
      • metrics-service
      • min-rectangle
      • morris-traversal
      • nearest-neighbors
      • notification-service
      • number-of-islands
      • proximity-service
      • reservoir-sampling
      • restaurant-customers
      • ride-sharding-service
      • search-engine
      • social-media-service
      • social-message-board
      • system-design-notes
      • task-framework
      • time-series-data
      • type-ahead
      • url-shortening-service
      • versions
      • video-streaming-service
      • web-crawler
    • misc
      • add-one-row-to-tree
      • combination-sum
      • group-anagrams
      • implement-trie
      • lfu-cache
      • minimum-number-of-arrows-to-burst-balloons
      • print-binary-tree
      • print-vertically
      • top-k-frequent-elements
      • valid-sudoku
    • week1
      • balanced-binary-tree
      • best-time-to-buy-and-sell-stock
      • binary-search
      • climbing-stairs
      • first-bad-version
      • flood-fill
      • implement-queue-using-stacks
      • invert-binary-tree
      • linked-list-cycle
      • lowest-common-ancestor-of-a-binary-search-tree
      • maximum-subarray
      • merge-two-sorted-lists
      • ransom-note
      • two-sum
      • valid-anagram
      • valid-palindrome
      • valid-parentheses
    • week2
      • 01-matrix
      • add-binary
      • backspace-string-compare
      • contains-duplicate
      • counting-bits
      • diameter-of-binary-tree
      • insert-interval
      • longest-palindrome
      • majority-element
      • maximum-depth-of-binary-tree
      • meeting-rooms
      • middle-of-the-linked-list
      • reverse-linked-list
      • roman-to-integer
    • week3
      • 3sum
      • binary-tree-level-order-traversal
      • clone-graph
      • coin-change
      • course-schedule
      • evaluate-reverse-polish-notation
      • implement-trie-prefix-tree
      • k-closest-points-to-origin
      • longest-substring-without-repeating-characters
      • min-stack
      • product-of-array-except-self
    • week4
      • accounts-merge
      • combination-sum
      • lowest-common-ancestor-of-a-binary-tree
      • merge-intervals
      • number-of-islands
      • permutations
      • rotting-oranges
      • search-in-rotated-sorted-array
      • time-based-key-value-store
      • validate-binary-search-tree
    • week5
      • binary-tree-right-side-view
      • construct-binary-tree-from-preorder-and-inorder-traversal
      • container-with-most-water
      • longest-palindromic-substring
      • partition-equal-subset-sum
      • sort-colors
      • spiral-matrix
      • string-to-integer-atoi
      • subsets
      • unique-paths
      • word-break
    • week6
      • daily-temperatures
      • find-all-anagrams-in-a-string
      • gas-station
      • house-robber
      • kth-smallest-element-in-a-bst
      • letter-combinations-of-a-phone-number
      • lru-cache
      • minimum-height-trees
      • task-scheduler
      • word-search
    • week7
      • design-add-and-search-words-data-structure
      • find-the-duplicate-number
      • group-anagrams
      • maximum-product-subarray
      • next-permutation
      • pacific-atlantic-water-flow
      • remove-nth-node-from-end-of-list
      • shortest-path-to-get-food
      • top-k-frequent-words
      • valid-sudoku
    • week8
      • contiguous-array
      • course-schedule-ii
      • decode-string
      • graph-valid-tree
      • longest-consecutive-sequence
      • longest-increasing-subsequence
      • maximum-width-of-binary-tree
      • odd-even-linked-list
      • path-sum-ii
      • rotate-array
      • swap-nodes-in-pairs
    • week9
      • basic-calculator
      • binary-tree-maximum-path-sum
      • find-median-from-data-stream
      • largest-rectangle-in-histogram
      • maximum-frequency-stack
      • maximum-profit-in-job-scheduling
      • merge-k-sorted-lists
      • minimum-window-substring
      • serialize-and-deserialize-binary-tree
      • trapping-rain-water
      • word-ladder
  • math
    • Combinatorics a Problem Based Approach
    • Math Problem Books
    • Mathjax
    • Principal Components Analysis
    • Problems
  • music
    • Albums
      • Tracklist
    • Albums
      • Tracklist
    • Albums
  • networks
    • Multicast
  • operating-systems
    • android
      • Cross Compiling C for Android
      • Running binaries for other architectures
    • shell
      • Find IP Address with Dig
      • Hashmaps in Bash
      • Looping in Bash
      • ShellSpec
      • Sort a CSV
      • Time it in Bash
    • xv6
      • 03-startup-and-organization
      • 04-spinlocks
      • 06-system-calls-from-user-mode
      • 07-memory-management
      • 08-page-table-architecture
      • 09-status-and-trap-architecture
      • 11-memory-layout
      • 12-linker-layout
      • 13-trap-handling
      • 14-kernel-startup
      • 28-disk-io
      • Intro
      • Memory and Caching
      • Risc-V Architecture
    • Virtualization
  • papers
    • 1949
      • Communication Theory of Secrecy Systems
    • 1952
      • A Method for the Construction of Minimum-Redundancy Codes
    • 1959
      • The Two Cultures
    • 1960
      • The unreasonable effectiveness of mathematics in the natural sciences. Richard courant lecture in mathematical sciences delivered at New York University, May 11, 1959
    • 1965
      • An Algorithm for the Machine Calculation of Complex Fourier Series
      • Cramming more components onto integrated circuits,
      • On the translation of languages from left to right
      • Solution of a Problem in Concurrent Programming Control
      • Three approaches to the quantitative definition of information
    • 1968
      • Sorting Networks and Their Applications
    • 1970
      • Organization and maintenance of large ordered indices
    • 1971
      • Normalized Data Base Structure
    • 1972
      • An approach to proving the correctness of data base operations
      • Retrieval efficiency using combined indices
    • 1973
      • Time bounds for selection
    • 1974
      • The Slab Allocator An Object-Caching Kernel Memory Allocator
      • The Unix Time-sharing System
    • 1976
      • Index selection in a self-adaptive data base management system
      • New directions in cryptography
    • 1977
      • A Universal Algorithm for Sequential Data Compression
    • 1978
      • Counting Large Numbers of Events in Small Registers
      • Distributed query processing in a relational data base system
      • The Smalltalk 76 Programming Environment
    • 1979
      • Access path selection in a relational database management system
      • How to share a secret
    • 1981
      • The K-D-B-tree
      • The Transaction Concept
    • 1982
      • Probabilistic Encryption
      • Probabilistic encryption & how to play mental poker keeping secret all partial information
    • 1983
      • A Distributed Algorithm for Minimum-Weight Spanning Trees
    • 1984
      • Efficient implementation of the smalltalk-80 system
      • End to End Arguments in System Design
      • Implementation techniques for main memory database systems
      • Reflections on Trusting Trust
    • 1985
      • Probabilistic counting algorithms for data base applications
    • 1988
      • A Case for Redundant Array of Inexpensive Disks (RAID)
      • Congestion avoidance and control
      • Development of the domain name system
    • 1994
      • A Behavioral Notion of Subtyping
    • 1996
      • The Rsync Algorithm
    • 2000
      • QuickCheck
    • 2001
      • Ideal Hash Trees
    • 2002
      • A Practical Multi-Word Compare and Swap Operation
      • An elementary proof of a theorem of Johnson and Lindenstrauss
      • Approximate Frequency Counts over Data Streams
    • 2003
      • Cache-oblivious algorithms
      • Xen and the art of virtualization
    • 2004
      • A unified theory of garbage collection
    • 2005
      • Cache-timing attacks on AES
      • Why Most Published Research Findings Are False
    • 2006
      • Formal certification of a compiler back-end
      • The Chubby Lock Service
    • 2007
      • Cache-oblivious streaming B-trees
    • 2008
      • MapReduce
      • New Features of Latin Dances: Analysis of Salsa, ChaCha, and Rumba
    • 2009
      • A Malloc Tutorial
      • SIMD-scan
      • Sort vs. Hash revisited
      • The Unreasonable Effectiveness of Data
    • 2010
      • FAST
      • The Akamai network
      • Tree indexing on solid state drives
    • 2011
      • Finding and understanding bugs in C compilers
      • Mathematizing C++ concurrency
    • 2012
      • Concurrent Tries with Efficient Nonblocking Snapshots
      • Don't Thrash How to Cache Your Hash on Flash
      • RRB-Trees Efficient Immutable Vectors
      • SipHash: A Fast Short-Input PRF
      • Test-case reduction for C compiler bugs
      • The Security Impact of a New Cryptographic Library
    • 2013
      • BLAKE2: Simpler, Smaller, Fast as MD5
    • 2014
      • CakeML
    • 2015
      • Fast Serializable Multi-Version Concurrency Control for Main-Memory Database Systems
      • How good are query optimizers, really?
    • 2016
      • A program optimization for automatic database result caching
      • Snowflake
    • 2018
      • The Case for Learned Index Structures
    • 2019
      • DuckDB
      • Lock-free Concurrent Data Structures and How to Model their Performance
    • 2020
      • Too Much Crypto
    • arxiv
      • An Empirical Evaluation of Columnar Storage Formats
      • Fast Deterministic Selection
      • Fast Random Integer Generation in an Interval
      • Future Directions for Optimizing Compilers
      • Pattern-defeating Quicksort
      • Tiny Pointers (2111.12800v1)
      • TinyLFU: A Highly Efficient Cache Admission Policy
  • personal-finance
    • Investments
    • social-security-benefits
    • using-401ks
  • programming-languages
    • c
      • polymorphism-in-c
      • The C Programming Language
      • tuples-in-c
    • cpp
      • a-tour-of-cpp
        • 1_basics
          • notes
        • 1-basics
          • 1-basics
          • notes
      • learn-cpp
        • README
      • kmp
    • elixir
      • Monotonic Time
    • erlang
      • Learn You Some Erlang
      • Programming Erlang
    • go
      • Build for Different Architectures in Go
      • Godocs
    • javascript
      • Check if Array in JS
    • kotlin
      • head-first-kotlin
        • Head First Kotlin
    • ocaml
      • Real World OCaml
    • ruby
      • regex-literals-in-ruby
    • rust
      • Rustup Docs
    • scheme
      • structure-and-interpretation-of-computer-programs
        • Structure and Interpretation of Computer Programs
      • the-little-schemer
        • The Little Schemer
  • real-world-systems
    • AWS Aurora
    • AWS Lambda
    • ideas
    • The Go Garbage Collector
  • recipes
    • recipes
      • (Murgh Makhani) Butter Chicken
      • Asian Chicken Noodle Soup
      • Baked Katsudon (Japanese Crispy Baked Cutlet Rice Bowl)
      • Birria De Res
      • Braised White Beans and Greens With Parmesan
      • Buffalo Chicken Rice Bowls
      • Butter Chicken
      • Cauliflower Piccata
      • Challah
      • Chicken Biryani
      • Chicken Gyros
      • Chicken Katsu Curry
      • Chickpea Salad Sandwich Recipe by Tasty
      • Chipotle Chicken (Copycat)
      • Chipotle Cilantro Lime Rice (Copycat)
      • Chipotle Recipes
      • Chipotle Steak (Copycat)
      • Coconut Chicken Curry
      • Cold Noodle Salad With Spicy Peanut Sauce
      • cookies
      • Copycat Chick-fil-A Sandwich
      • Copycat Chipotle Black Beans
      • Copycat Chipotle Guacamole Recipe
      • Crab Cream Korokke Recipe (Japanese-style Deep-Fried Croquettes Filled with White Sauce and Seafood)
      • Creamy Asparagus Pasta
      • Creamy Baked Macaroni and Cheese
      • Crispy Gnocchi With Burst Tomatoes and Mozzarella
      • Crispy Sheet-Pan Noodles With Glazed Tofu
      • Croissants
      • Cucumber-Avocado Salad
      • Curry Udon
      • Double Lemon Chicken
      • Egg Drop Soup with Crab
      • everyday-pancakes
      • Extra-Creamy Scrambled Eggs
      • Ginger-Dill Salmon
      • Gingery Fried Rice With Bok Choy, Mushrooms and Basil
      • Greek Slow Roasted Leg of Lamb
      • Grilled Za’atar Chicken With Garlic Yogurt and Cilantro
      • Hainanese Chicken Rice Recipe by Tasty
      • Homemade Naan
      • Jamaican Curry Chicken and Potatoes
      • Japanese Curry
      • japanese-hamburger-steak-hambagu
      • japanese-soufflé-pancakes
      • karaage-fried-chicken-recipe-by-tasty
      • Korean Barbecue-Style Meatballs
      • Korean BBQ at Home
      • Korean-style BBQ Beef Recipe by Tasty
      • Lemony White Bean Soup With Turkey and Greens
      • Lo Mein
      • Oven-Roasted Chicken Shawarma
      • Ozoni (Japanese New Year Mochi Soup - Kanto Style)
      • Pad Thai
      • Pan Fried Chickpeas With Beef
      • pearl-couscous-with-chicken-and-chickpeas
      • perfect-buttermilk-pancakes
      • peshawari-chicken-karahi
      • Pineapple-Marinated Chicken Breasts
      • Potato Korokke
      • Sheet-Pan Bibimbap
      • Sheet-Pan Chicken With Zucchini and Basil
      • slow-roast-leg-of-lamb
      • Spiced Roast Chicken With Tangy Yogurt Sauce
      • taiwanese-braised-pork-belly-made-in-an-instant-pot
      • The Perfect Rice Recipe (Spanish Paella)
      • the-classic-kimchi-jjigae
      • Tonjiru (Pork and Vegetable Miso Soup)
      • Updated No-Knead Bread
      • uzbek-plov
      • vanilla-creme-brulee
      • Vegan Tantanmen With Pan-Fried Tofu
      • vegan-hawaiian-tofu-and-pineapple-sandwich
      • vegetarian-pad-see-ew
    • Recipes
  • security
    • cves
      • CVE-2024-3094 (SSHD Backdoor Using xz)
    • Constant Time Comparison
    • Fail2Ban
  • software-architecture
    • Dependency Inversion
    • invariant-pyramid
    • links
    • static-vs-dynamic-schemas
  • system-design
    • systemsexpert
      • API Design
      • Availability
      • Caching
      • Client Server Model
      • Configuration
      • Hashing
      • Introduction
      • Key Value Stores
      • Latency and Throughput
      • Leader Election
      • Load Balancers
      • Logging and Monitoring
      • Mapreduce
      • Network Protocols
      • peer-to-peer-networks
      • polling-and-streaming
      • proxies
      • publish-subscribe-pattern
      • Rate Limiting
      • Relational Databases
      • Replication and Sharding
      • Security and HTTPS
      • Specialized Storage Paradigms
      • Storage
      • What Are Design Fundamentals?
    • design-a-movie-ticketing-system
    • design-a-video-upload-system-with-low-bandwidth
    • design-a-voting-system
    • design-an-atm
    • design-netflix
    • types-in-system-design
  • talks
    • 1999-mount-holyoke-commencement-speech
    • antitrust-commission-jeff-bezos
    • Background
    • Background
    • creative-thinking
    • duties-of-american-citizenship
    • Enough
    • george-washingtons-resignation
    • gettysburg-address
    • i-am-prepared-to-die
    • Inventing on Principle
    • learning-to-learn
    • Make-your-bed
    • Obama-at-the-democratic-national-convention
    • on-the-death-of-martin-luther-king
    • reshma-saujani-smith-college-commencement-speech
    • The Third Philippic
    • The-art-of-doing-science-and-engineering
    • Transcript
    • Transcript
    • Transcript
    • Transcript
    • Transcript
    • Transcript
    • Transcript
    • Transcript
    • Video
    • we-shall-fight-on-the-beaches
    • What Matters More Than Your Talents
    • you-and-your-research
  • til
    • deque-in-c
    • dtruss
    • heredocs
    • HTML to Text
    • Linux File Partitions
    • min-stack-in-c
    • Rsync to Remote Server
    • Smart Pointers in Rust
    • Sync With Android
    • Traceroute
    • Use Find instead of Globstar
    • Use Sbrk to Adjust the Program Break
  • to-read
    • "Why is the Rust compiler so slow?"
    • A deep dive into LSM Tree Architecture
    • A definitive guide to sealed traits in Rust
    • A Philosophy of Software Design vs Clean Code
    • Abseil open-source foundational code
    • Accelerated Learning: Learn Faster and Remember More
    • Binary Banshees and Digital Demons
    • Compaction
    • Files are hard
    • How much code does that proc macro generate?
    • How web bloat impacts users with slow devices
    • LibSQL Replication
    • Magnifying Glass
    • Mental Models: The Best Way to Make Intelligent Decisions (~100 Models Explained)
    • Notes on concurrency bugs
    • Protobuf Tip #1: Field Names Are Forever · mcyoung
    • The Day The Standard Library Died | cor3ntin
    • The messy reality of SIMD (vector) functions
    • The Rust Calling Convention We Deserve · mcyoung
    • The Ultimate Deliberate Practice Guide: How to Be the Best
    • They Still Haven’t Told You
    • Unsoundness and accidental features in the #[target_feature] attribute
    • Use These Simple Strategies to Retain Everything You Read
    • What Is a Blanket Implementation?
    • What the Hell Is a Target Triple? · mcyoung
    • What's worked in Computer Science: 1999 v. 2015
    • You and Your Research
    • You might not need Redis
  • tools
    • caddy
      • Restart Caddy on Startup
      • SSL Certs on Localhost
    • git
      • Checkout File from Another Branch
      • delta
      • Empty Git Commits
      • Follow Changes Made to File
      • git-instaweb
      • Multiple Git Identities
      • Push to Multiple Remotes at the Same Time
      • Setup Git on a Server
      • setup-gitea
    • homebrew
      • Using Different Homebrew Formula Versions
    • hugo
      • Cstate
    • packages
      • Aerc
      • chawan
      • Comby
      • Gooey
      • Id3tool
      • jenv
      • lazy-docker
      • local-stack
      • Miniserve
      • mise
      • Newsboat
      • pdf-tocgen
      • Sc-im
      • sdcv
      • watchexec
      • wikiman
    • pandoc
      • EPUB to HTML with Pandoc
      • to-pdf
    • vim
      • Add a Tab to Vim
      • Delete to Char
      • Diffing with Vim
      • Refer to Current File
      • Search and Replace with Vim
      • Sorting with Vim
      • Yanking Text to Registers
  • work
    • Architecture Design Records
    • Create a Brag Doc
    • managing-notes
    • Types of Notes
Home

❯

books

❯

the dynamodb book

❯

strategies for one to many relationships

strategies-for-one-to-many-relationships

May 12, 20231 min read

for one-to-many relationships”

Strategies for one-to-many relationships

Prev: the-importance-of-strategies Next: strategies-for-many-to-many-relationships

Prev: the-importance-of-strategies Next: strategies-for-many-to-many-relationships


Graph View

Backlinks

  • strategies-for-many-to-many-relationships
  • the-importance-of-strategies

Created with Quartz v4.5.1 © 2025

  • Homepage
  • GitHub
  • RSS
  • Sitemap