@rkenmi - Quick Numbers in Software Engineering Cheatsheet

Quick Numbers in Software Engineering Cheatsheet


January 23, 2021

Quick Numbers in Software Engineering Cheatsheet


Back to Top

Updated on December 22, 2021


This is the front... just so you know

Preface

This article is a cheatsheet and a collection of tips/tricks for doing back of the envelope calculations.

Numbers

Data Types to Bytes

Note: keep in mind that these are general estimates. Depending on the language that implements them, the actual size stored in memory may vary.

Data Type Byte(s) Explanation
CHAR 1-4 bytes 1 byte is enough to cover all the characters in ASCII and then some (1 byte = 255 character choices). Some languages that allow Unicode characters (144,697 character choices) will have to allocate more bytes per character, so some languages may use up 2-4 bytes rather than just 1.
BOOL 1 byte True or False state can technically be represented by 1 bit, but the CPU can't address anything smaller than a byte.
INT 4 bytes Decimals range from \([-2^{31}, 2^{31}]\). Up to ~4 billion numbers. Each byte has 8 bits, so \(\frac{32}{8} = 4\)
BIGINT 8 bytes It uses twice the number of bits as INT and doubles the ranges of INT, so it is called a BIGINT. Decimals of range \([-2^{63}, 2^{63}]\) can now be stored.
FLOAT 4 bytes Same number of bytes as INT. In SQL, precision is supported up to 0 to 23 decimal places. Single precision.
DOUBLE 8 bytes It uses twice the number of bits as FLOAT, so its called a DOUBLE. FLOAT has accuracy issues due to its limited floating point precisions that can't be widely represented under 4 bytes.
DATETIME 8 bytes Contains date and time. A four-byte integer for date packed as `YYYY×10000 + MM×100 + DD` and a four-byte integer for time packed as `HH×10000 + MM×100 + SS`. Some implementations make this size more compact (down to 5 bytes in newer versions of SQL) but 8 bytes is a reasonable estimate for a DATETIME value.

Size Tables

Pre-requisites: See the chart here for a quick primer on numbers.

Number (numerical) Number (english) Power Byte
1 One \(10 ^ 0\) 1 byte
1,000 Thousand \(10 ^ {3}\) 1 KB (1 kilobyte)
1,000,000 Million \(10 ^ {6}\) 1 MB (1 megabyte)
1,000,000,000 Billion \(10 ^ {9}\) 1 GB (1 gigabyte)
1,000,000,000,000 Trillion \(10 ^ {12}\) 1 TB (1 terabyte)
1,000,000,000,000,000 Quadrillion \(10 ^ {15}\) 1 PB (1 petabyte)

Time Tables

Millisecond (\(10^{-3}_{sec}\)) \(1_{sec} = 1,000_{ms}\)
Microsecond (\(10^{-6}_{sec}\)) \(1_{sec} = 1,000,000_{μs}\)
Nanosecond (\(10^{-9}_{sec}\)) \(1_{sec} = 1,000,000,000_{ns}\)

Time to Seconds

Hour Day Month Year
\(60 * 60 = 3600\) \(3600 * 24 = 86400\) \(86400 * 30 = 2592000\) \(2592000 * 12 = 31104000\)
3600 secs approx. ~85k secs approx. ~2.5 million secs approx. ~30 million secs

Requests

Requests Requests per second
\(\text{2.5 million}_{req/month}\) \(\text{1}_{req/sec}\)
\(\text{86,400}_{req/day}\) \(\text{1}_{req/sec}\)

This is all you need to know really. There are 2.5 million seconds in 1 month. This means that with 1 request per second, you have 2.5 million requests in that whole month.

Most request counts (for a month) usually range from millions to billions, so having this back-of-the-envelope formula should get you started for easy conversions.

Latency to Remember

These numbers from System Design Primer is a good reference sheet to remember when designing systems.

Actions Nanoseconds Microseconds Milliseconds
Blazing Fast
L1 cache reference \(0.5 ns\)
Branch misredirect \(5 ns\)
L2 cache reference (L1 is about 14x faster) \(7 ns\)
Mutex lock/unlock \(25 ns\)
Main Memory Reference (20x slower than L2 cache) \(100 ns\)
Very Fast
Compress 1 KB (i.e. with Zippy) \(10,000 ns\) \(10 μs\)
Send 1 KB over 1 Gbps network \(10,000 ns\) \(10 μs\)
Read 4 KB randomly from SSD \(150,000 ns\) \(150 μs\) \(0.15 ms\)
Read 1 MB sequentially from memory \(250,000 ns\) \(250 μs\) \(0.25 ms\)
Round trip within same datacenter \(500,000 ns\) \(500 μs\) \(0.5 ms\)
Read 1 MB sequentially from SSD (~1 GB/sec SSD, 4 times slower than RAM) \(1,000,000 ns\) \(1,000 μs\) \(1 ms\)
Somewhat fast
HDD seek (i.e. 7200 RPM disk drives) \(10,000,000 ns\) \(10,000 μs\) \(10 ms\)
Read 1 MB sequentially from 1 Gbps network \(10,000,000 ns\) \(10,000 μs\) \(10 ms\)
Read 1 MB sequentially from HDD \(30,000,000 ns\) \(30,000 μs\) \(30 ms\)
Send a packet CA -> Netherlands -> CA \(150,000,000 ns\) \(150,000 μs\) \(150 ms\)

Article Tags:
mathsystem design