Ivan's wiki

Site Tools

numbers-every-programmer-should-know

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
numbers-every-programmer-should-know [May 23, 2026 at 00:12] – Ivan Janevskinumbers-every-programmer-should-know [August 22, 2026 at 15:22] (current) – external edit 127.0.0.1
Line 1: Line 1:
 # Numbers every programmer should know # Numbers every programmer should know
-**Numbers every programmer should know** is a short document listing latencies of various computer operations. The list is given by a computer scientist [Jeff Dean](https://en.wikipedia.org/wiki/Jeff_Dean). 
  
-It illustrates how various high-level operations exponentially take longer time to perform compared to various low-level operations.+**[Numbers every programmer should know](https://colin-scott.github.io/personal_website/research/interactive_latency.html)** is a reference of hardware latencies: L1 cache (1ns), memory (100ns), SSD (1ms), network (10ms). These span orders of magnitude and shape every performance decision in systems design.
  
-## Content +Based on Jeff Dean's seminal analysis; values evolve as technology changes.
-``` +
-Latency Comparison Numbers (~2012) +
----------------------------------- +
-L1 cache reference                           0.5 ns +
-Branch mispredict                            5   ns +
-L2 cache reference                           7   ns                      14x L1 cache +
-Mutex lock/unlock                           25   ns +
-Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache +
-Compress 1K bytes with Zippy             3,000   ns        3 us +
-Send 1K bytes over 1 Gbps network       10,000   ns       10 us +
-Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD +
-Read 1 MB sequentially from memory     250,000   ns      250 us +
-Round trip within same datacenter      500,000   ns      500 us +
-Read 1 MB sequentially from SSD*     1,000,000   ns    1,000 us    1 ms  ~1GB/sec SSD, 4X memory +
-Disk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtrip +
-Read 1 MB sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20X SSD +
-Send packet CA->Netherlands->CA    150,000,000   ns  150,000 us  150 ms+
  
-Notes +## Example
------ +
-1 ns = 10^-9 seconds +
-1 us = 10^-6 seconds = 1,000 ns +
-1 ms = 10^-3 seconds = 1,000 us = 1,000,000 ns+
  
-Credit +Typical latency hierarchy (approximate 2020s values):
------- +
-By Jeff Dean:               http://research.google.com/people/jeff/ +
-Originally by Peter Norvig: http://norvig.com/21-days.html#answers+
  
-Contributions 
-------------- 
-'Humanized' comparison:    https://gist.github.com/hellerbarde/2843375 
-Visual comparison chart:   http://i.imgur.com/k0t1e.png 
-Interactive Prezi version: https://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development/latency.txt 
 ``` ```
- +L1 cache reference:           1 ns 
-## Criticism (Opinion) +L2 cache reference:           7 ns 
-While the list is illustrative, the claim that every programmer needs to "know" these numbers is not justified. Certainly it's not necessary to know these numbers by heart for one to be an effective programmer. The name "numbers every programmer should know" is thus a misnomer. +Main memory reference:       100 ns 
- +Mutex lock/unlock:           100 ns 
-The list mixes different categories of programming which sit at completely different hierarchies. A high-level web programmer almost never needs to know about mutex lock/unlock or branch misprediction; A low-level embedded programmer almost never needs to know the packet roundtrip between California and Netherlands. +Compress 1K with Zippy:     3,000 ns 
- +Network SSD read (4K):    150,000 ns 
-In addition, these numbers evolve as the technology continues to evolve. Because we're talking about latencies, they are subjected to eternal factors (electromagnetic interference, network congestion, ...). Therefore, even if you do know these numbers by heart, there is no context in which you will find their value useful. +Disk seek:             10,000,000 ns 
- +Network RTT CA↔NL:    150,000,000 ns
-As mentioned, the list should only be understood as illustrative.+
 ``` ```
-L1 cache < Branch mispredict < ... < Send packet CA -> Netherlands -> CA 
-``` 
- 
-## Source 
- 
- - https://gist.github.com/jboner/2841832 
  
numbers-every-programmer-should-know.1779495120.md.gz · Last modified: by Ivan Janevski