📌 Systems Cheatsheet

Essential Powers of Two

Powers of two is fundamental in computing, as they frequently represent limits, capacities, and common units of measurement. The following table consolidates key powers of two that are particularly useful for quick recall.

Core Computer Storage Units

The fundamental units of digital information and their conversions is crucial in computer science and engineering. Unlike the decimal system (base-10) used in everyday life, computers primarily operate using the binary system (base-2). This often leads to differences in how “kilo,” “mega,” and “giga” are interpreted in computing contexts compared to their standard metric definitions.

A consolidated reference for common bit and byte units are shown below:

Prefix Comparison

It’s worth noting the distinction between the traditional binary prefixes (powers of 2) and the decimal prefixes (powers of 10) used in the International System of Units (SI).

• Binary Prefixes (IEC Standard): KiB (kibibyte), MiB (mebibyte), GiB (gibibyte), TiB (tebibyte) use powers of $2^{10}$ $\to \hspace{0.1em}$ precise for computer memory and storage during programming.
• Decimal Prefixes (SI Standard): KB (kilobyte), MB (megabyte), GB (gigabyte), TB (terabyte) typically use powers of $10^3$ $\to \hspace{0.1em}$ used by hard drive manufacturers to express capacity, leading to slight discrepancies with the actual binary capacity reported by operating systems.

For example, a 1 TB hard drive is $10^{12}$ bytes, which is slightly less than 1 TiB ($2^{40}$ bytes).

Primitive Data Types: (64-bit Systems)

Understanding the characteristics of primitive data types—their size in memory and the range of values they can hold—is fundamental for efficient programming, especially in systems-level languages like C++ and Rust. This knowledge is crucial for memory optimization, avoiding overflow errors, and ensuring data integrity. While Python’s dynamic typing abstracts many of these details, it’s still beneficial to grasp the underlying concepts.

The below tables consolidates information on common primitive types, their typical sizes on a 64-bit architecture, and their value ranges, along with comparisons across C++, Rust, and Python.

Signed Data Types️

These types can represent both positive and negative values. They use a bit (typically the most significant one) to indicate the sign.

Unsigned Data Types

These types can only represent non-negative values (zero and positive numbers), allowing them to store larger positive values than their signed counterparts of the same size.

Special Types

These types don’t fit into the signed/unsigned numeric categories but are fundamental building blocks. Python’s int and str types are included here as they are dynamically sized and don’t have fixed-width signed/unsigned counterparts.

Best Practices

• Integer Sizing:

  • C++ & Rust: Offer fixed-width integers (e.g., int32_t, i32) which guarantee the same size on any platform. For portability and unambiguous code in C++, it is recommended to use these over generic types like int or long.
  • Python: Its int type has arbitrary precision, meaning it automatically uses more memory as needed to store larger numbers and has no practical size limit.
  • Mixing Signed & Unsigned Types: This is a classic C++ bug. A condition like i < n where i is signed and n is unsigned can lead to unexpected behavior due to implicit type promotion rules. Rust’s strict type system prevents this by disallowing operations between different types without an explicit cast.

• Characters:

  • The char type is fundamentally different. In C++, char is a 1-byte type typically holding an ASCII value. In Rust, char is a 4-byte type representing any Unicode Scalar Value, making it suitable for all languages.
  • char Discrepancy: A C++ char is a 1-byte type representing an ASCII character. In contrast, a Rust char is always 4 bytes, representing a full Unicode Scalar Value.

• Pointer-Sized Integers:

  • usize (Rust) and size_t (C++) are crucial for indexing and memory-related calculations. Their size matches the system’s address space (8 bytes on a 64-bit system), ensuring they can always hold the size of any object in memory.

• Strings:

  • All three languages provide dynamic, heap-allocated strings (std::string, String, str) for mutable text.
  • Rust and modern C++ also offer lightweight, immutable string “views” or “slices” (&str and std::string_view) for efficient, non-owning access to string data.

Quick Memory Estimation Guide

This table provides quick, practical estimates for the memory footprint of common data types and system-level structures, essential for performance-aware software design.

Memory Allocation

Indexing & Memory Allocation

• Use the Right Type for Sizes: For indexing or representing object sizes, always use size_t in C++ and usize in Rust. These types are guaranteed to be the width of a memory pointer on the target platform (e.g., 64 bits on a 64-bit system).
• Stack vs. Heap Allocation: Know when to use the heap. Prefer the heap (Vec, Box in Rust) when dealing with large amounts of data or when the data’s size is not known at compile time. A typical thread’s stack size is small (1-8 MB).

Stack vs Heap

Cold Estimations

• ✅ Estimate RAM usage of a struct with multiple fields
• ✅ Say how much memory vector<int> of size 1M uses
• ✅ Recall signed/unsigned integer ranges instantly
• ✅ Explain overflow behavior in Rust vs C++ vs Python
• ✅ Index an array in Rust with usize and know why
• ✅ Know what sizeof(int*) is on your target system
• ✅ Use std::numeric_limits<T>::max() or T::MAX in Rust