Takashi's Notes

      • Qualities of an Architecture Decision Record
      • Use Linux
      • Use Rust
        • 63 Tree Sum
        • 78 Zero Matrix
        • 132 Height Balanced Tree
        • 251 Univalue Tree
        • 867 Count Nodes in Complete Binary Tree
        • Binary Exponentation
        • Minimum Queue
        • Minimum Stack
          • 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
          • 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
          • 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
          • convex-hull
          • line-segment-intersection
          • minimum-euclidean-distance
          • point-in-polygon
          • point-location-test
          • polygon-area
          • polygon-lattice-points
          • 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
          • 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
          • 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
          • 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
          • apartments
          • array-division
          • collecting-numbers
          • collecting-numbers-ii
          • 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
          • 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
          • 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-C++
            • ctci-rust-arrays
          • CTCI in Rust
        • bfs
        • calculate-best-discount
        • insert-interval
        • lowest-common-ancestor-in-binary-tree
        • shortest-path-in-binary-matrix
          • 62-unique-paths
          • 104-maximum-depth-of-binary-tree
          • binary-tree-inorder-traversal-rs
          • Two Sum
          • valid-parentheses-rs
      • Links
      • The Bitter Lesson
      • proof-of-work
      • Types of PoS
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • Advanced Internetworking
        • Applications
        • Congestion Control
        • Direct Links
        • End-to-End Data
        • End-to-End Protocols
        • Foundation
        • Internetworking
        • Network Security
        • 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
        • 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 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
        • 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
        • a-case-study-designing-a-document-editor
        • behavioral-patterns
        • conclusion
        • creational-patterns
        • introduction
        • structural-patterns
        • 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
        • Asynchronous Rust
        • Beyond Standard Rust
        • Concepts
        • Dependencies
        • Introduction
        • Tooling
        • Types
        • 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
        • Access Patterns
        • Data
        • Indexes and Indexing
        • Query Response Time
        • Replication Lag
        • Server Metrics
        • Sharding
        • Transactions
        • 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
        • 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
        • 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
        • 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
        • 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-chapter-1
        • 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
        • 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
        • 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
        • 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-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
        • 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
        • 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
        • 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
        • cardinality
        • frequency
        • hashing
        • membership
        • rank
        • similarity
        • Building an Application
        • Exploring Clojure
        • Functional Programming
        • Getting Started
        • Java Interop
        • Macros
        • Multimethods
        • Protocols and Datatypes
        • Specifications
        • State and Concurrency
        • Unifying Data with Sequences
        • 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
        • 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
        • 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
        • 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
        • 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
        • anatomy-of-an-index
        • clustering-data
        • execution-plans
        • modifying-data
        • partial-results
        • performance-and-scalability
        • sorting-and-grouping
        • the-join-operation
        • the-where-clause
        • 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
        • 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
        • 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
        • applications
        • benchmarking
        • bpf
        • case-study
        • cloud-computing
        • cpus
        • disks
        • file-systems
        • ftrace
        • introduction
        • memory
        • methodologies
        • network
        • observability-tools
        • operating-systems
        • perf
        • 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
        • 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
        • 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
        • 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-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
        • february
        • january
        • 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
        • 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
        • 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
        • '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?
        • 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
        • 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
      • 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
        • 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
          • Chapter 1
          • Compilers/Crafting-Interpreters/2_Map_Of_Territory
          • Compilers/Crafting-Interpreters/3_Lox_Language
          • crafting-interpreters-chapter-4
          • notes
        • Compiler Optimizations
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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?
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
        • 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
      • History
      • How TLS Works
      • Arrays
      • Big-o-complexity
      • HashTables
      • HyperLogLogs
      • Iteration Vs Recursion
      • Memory
      • Nodes
      • pointers
      • Singly Linked Lists
      • Time Complexity of Data Structures
        • Redis Data Modeling
        • 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
        • effective-sql
        • email-registration
        • mysql-8
        • read-only-table-swap
        • setup-pgtap-and-pg-prove
        • setup-postgrest-dbmate-redoc
        • a-basic-time-series-database
      • 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
      • tls
      • 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
      • analyze-webpack-bundle-size
        • Hamming Codes
              • 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?
          • 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
          • trivia
          • type-ahead
          • url-shortening-service
          • versions
          • video-streaming-service
          • web-crawler
          • 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
          • 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
          • 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
          • 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
          • 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
          • 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
          • 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
          • 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
          • 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
          • 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
        • Combinatorics a Problem Based Approach
        • Math Problem Books
        • Mathjax
        • Principal Components Analysis
        • Problems
        • Albums
        • Albums
        • Albums
        • Multicast
          • Cross Compiling C for Android
          • Running binaries for other architectures
          • Find IP Address with Dig
          • Hashmaps in Bash
          • Looping in Bash
          • ShellSpec
          • Sort a CSV
          • Time it in Bash
          • 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
          • Sorting Networks and Their Applications
          • Ten Quick Tips for effective Dimensionality Reduction
          • The Unreasonable Effectiveness of Data
          • A Behavioral Notion of Subtyping
          • A Case for Redundant Array of Inexpensive Disks (RAID)
          • A Method for the Construction of Minimum-Redundancy Codes
          • A Universal Algorithm for Sequential Data Compression
          • Reflections on Trusting Trust
          • The Smalltalk 76 Programming Environment
          • A Practical Multi-Word Compare and Swap Operation
          • Probabilistic Encryption
          • Concurrent Tries with Efficient Nonblocking Snapshots
          • Don't Thrash How to Cache Your Hash on Flash
          • Ideal Hash Trees
          • RRB-Trees: Efficient Immutable Vectors
          • The Chubby Lock Service
          • The Rsync Algorithm
          • End to End Arguments in System Design
          • Solution of a Problem in Concurrent Programming Control
          • The Akamai Network
          • The Slab Allocator
          • a-protocol-for-packet-network-intercommunication
          • Reflections on Trusting Trust
          • The Unix Time-Sharing System
          • The Two Cultures
          • The Unreasonable Effectiveness of Mathematics in the Natural Sciences
          • Why most published research findings are false
          • Counting Large Numbers of Events in Small Registers
        • Investments
        • using-401ks
          • polymorphism-in-c
          • The C Programming Language
          • tuples-in-c
              • notes
              • 1-basics
              • notes
            • README
          • kmp
          • Monotonic Time
          • Learn You Some Erlang
          • Programming Erlang
          • Build for Different Architectures in Go
          • Godocs
          • Check if Array in JS
            • Head First Kotlin
          • Real World OCaml
          • regex-literals-in-ruby
          • Rustup Docs
            • Structure and Interpretation of Computer Programs
            • The Little Schemer
        • AWS Aurora
        • AWS Lambda
        • ideas
        • The Go Garbage Collector
          • (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
          • CVE-2024-3094 (SSHD Backdoor Using xz)
        • Constant Time Comparison
        • Fail2Ban
        • Dependency Inversion
        • invariant-pyramid
        • links
        • static-vs-dynamic-schemas
          • 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
        • 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
        • 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
        • "Why is the Rust compiler so slow?"
        • A definitive guide to sealed traits in Rust
        • Compaction
        • Files are hard
        • How much code does that proc macro generate?
        • How web bloat impacts users with slow devices
        • Notes on concurrency bugs
        • Protobuf Tip #1: Field Names Are Forever · mcyoung
        • The messy reality of SIMD (vector) functions
        • Unsoundness and accidental features in the #[target_feature] attribute
        • What Is a Blanket Implementation?
        • What the Hell Is a Target Triple? · mcyoung
        • What's worked in Computer Science: 1999 v. 2015
        • You might not need Redis
          • Restart Caddy on Startup
          • SSL Certs on Localhost
          • 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
          • Using Different Homebrew Formula Versions
          • Cstate
          • Aerc
          • chawan
          • Comby
          • Gooey
          • Id3tool
          • jenv
          • lazy-docker
          • local-stack
          • Miniserve
          • mise
          • Newsboat
          • pdf-tocgen
          • Sc-im
          • sdcv
          • watchexec
          • wikiman
          • EPUB to HTML with Pandoc
          • to-pdf
          • 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
        • Architecture Design Records
        • Create a Brag Doc
        • managing-notes
        • Types of Notes
    Home

    ❯

    courses

    ❯

    lectures notes on game theory

    ❯

    Extensive form games with chance moves and imperfect information

    Extensive form games with chance moves and imperfect information

    Jun 02, 20231 min read

    Extensive form games with chance moves and imperfect information

    Prev: auctions Next: repeated-games

    Prev: auctions Next: repeated-games


    Graph View

    Backlinks

    • Auctions
    • Repeated games

    Created with Quartz v4.4.0 © 2025

    • Homepage
    • GitHub
    • RSS
    • Sitemap