Module

/ˈɛsˌræm/

noun … “High-speed, volatile memory with no refresh needed.”

SRAM (Static Random Access Memory) is a type of volatile memory that stores data using bistable latching circuitry instead of capacitors, unlike DRAM. This design allows SRAM to retain data as long as power is supplied, without requiring periodic refresh cycles, resulting in faster access times. SRAM is commonly used for CPU cache, small buffers, and other performance-critical applications where speed is more important than density or cost.

Key characteristics of SRAM include:

• Volatile: loses data when power is removed.
• No refresh needed: data is stable while powered.
• Fast access: typically faster than DRAM, ideal for caches and registers.
• Low density and higher cost: fewer bits per unit area compared to DRAM.
• Integration: often embedded close to the CPU for ultra-low latency access.

Workflow example: Using SRAM as a CPU cache:

cache_line[4] = SRAM.read(address)
cache_line[2] = 42                 -- Modify cached value
SRAM.write(address, cache_line)     -- Write back to memory if needed

Here, SRAM serves as a temporary high-speed storage near the CPU, enabling rapid reads and writes for performance-critical operations.

Conceptually, SRAM is like a set of drawers next to your workstation: items can be retrieved and stored almost instantly, but they disappear if the power is turned off.

See Memory, DRAM, Cache, CPU, Memory Management.

/ræm/

noun … “Fast, temporary memory for active data.”

RAM (Random Access Memory) is a type of volatile memory that provides fast, temporary storage for data and instructions currently in use by a CPU. Unlike non-volatile memory such as Flash or ROM, the contents of RAM are lost when power is removed. RAM is critical for system performance because it allows rapid read and write operations, supporting multitasking, buffering, and caching.

Key characteristics of RAM include:

• Volatility: data is cleared when power is off.
• Random access: any memory location can be read or written in constant time.
• Speed: significantly faster than most storage devices.
• Types: includes DRAM (Dynamic RAM), SRAM (Static RAM), and specialized forms like VRAM for graphics.
• Integration: directly connected to the CPU for rapid data access and execution.

Workflow example: Accessing RAM in a program:

int buffer[5] = {1, 2, 3, 4, 5}   -- Stored in RAM
buffer[2] = 10                       -- Modify third element directly
sum = 0
for int i = 0..4:
    sum += buffer[i]                 -- Read elements from RAM

Here, the buffer array resides in RAM, allowing the CPU to read and write elements quickly, illustrating temporary active storage.

Conceptually, RAM is like a desk where you place documents you are currently working on: items are quickly accessible, but they vanish if you leave the desk without filing them elsewhere.

See Memory, CPU, Cache, DRAM, SRAM.

/nɒn ˈvɑːlətɪl ˈmɛməri/

noun … “Memory that retains data without power.”

Non-Volatile Memory (NVM) is a type of memory that preserves stored information even when the system loses power. Unlike volatile memory such as RAM, which requires constant power to maintain data, non-volatile memory maintains content permanently or until explicitly overwritten. This property makes NVM essential for storage devices, firmware, and persistent configuration in embedded systems.

Key characteristics of Non-Volatile Memory include:

• Persistence: data remains intact without electrical power.
• Write endurance: limited number of program/erase cycles in devices like Flash or EEPROM.
• Access speed: generally slower than volatile memory, but modern technologies like NVDIMM and 3D XPoint bridge this gap.
• Integration with controllers: often requires wear leveling, ECC, or bad block management for reliability.
• Applications: used in SSDs, BIOS storage, firmware, and persistent logs.

Workflow example: Writing configuration to non-volatile memory:

function save_config(config_data) {
    nv_memory.erase_sector(sector_address)
    nv_memory.write(sector_address, config_data)
}

Here, the data is stored in NVM such as EEPROM or Flash, ensuring it remains available after power loss.

Conceptually, Non-Volatile Memory is like a chalkboard etched in stone: once written, the information stays indefinitely, unlike a whiteboard that disappears when the power or environment changes.

See Memory, Flash, EEPROM, ROM, SSD.

/ˈbuːtˌloʊdər/

noun … “Initial program that starts the system.”

Bootloader is a small, specialized program stored in non-volatile memory such as ROM or Flash, responsible for initializing hardware components and loading the operating system or runtime environment into RAM. It serves as the first stage of the boot process, bridging the gap between firmware and the OS, ensuring that the system starts reliably and securely.

Key characteristics of Bootloader include:

• Hardware initialization: configures CPU, memory, and peripheral devices before OS execution.
• OS loading: locates the operating system kernel or runtime and transfers control.
• Security: may implement verification mechanisms, such as digital signatures or secure boot, to prevent unauthorized code execution.
• Multi-stage operation: complex systems may use primary and secondary bootloaders for modular startup.
• Configurability: often supports boot options, recovery modes, and firmware updates.

Workflow example: Booting an embedded system:

function boot_system() {
    bootloader.initialize_hardware()
    bootloader.verify_os_signature()
    kernel = bootloader.load_os("RAM")
    cpu.execute(kernel)
}

Here, the bootloader prepares hardware, verifies the OS, loads it into RAM, and transfers control to the CPU for execution.

Conceptually, Bootloader is like a conductor at the start of a symphony: it ensures all instruments (hardware) are ready, the sheet music (OS) is in place, and then signals the orchestra (CPU) to begin the performance.

See Firmware, ROM, Flash, Memory, CPU.

/iˌiːˌpɹoʊˈm/

noun … “Electrically erasable programmable memory.”

EEPROM (Electrically Erasable Programmable Read-Only Memory) is a type of non-volatile memory that can be electrically erased and reprogrammed at the byte level. Unlike traditional ROM, which is fixed at manufacture, and standard Flash memory, which erases in large blocks, EEPROM allows fine-grained updates without removing surrounding data, making it suitable for storing configuration settings, firmware, or small amounts of persistent data in embedded systems.

Key characteristics of EEPROM include:

• Non-volatility: retains stored information without power.
• Byte-level programmability: allows individual bytes to be erased and rewritten.
• Limited write cycles: each memory cell supports a finite number of program/erase operations, requiring careful usage.
• Integration: commonly embedded in microcontrollers, BIOS chips, and small devices requiring persistent configuration storage.
• Slower than RAM: optimized for infrequent writes, not high-speed access.

Workflow example: Updating a configuration parameter in EEPROM:

function update_config(address, value) {
    eeprom.erase_byte(address)
    eeprom.write_byte(address, value)
}

Here, a specific byte in EEPROM is erased and then rewritten with new data, preserving other bytes in memory.

Conceptually, EEPROM is like a digital sticky note where each cell can be erased and rewritten individually, retaining its content even when the device loses power.

See Memory, ROM, Flash, Microcontroller, Firmware.

/ˈfɜːrmwɛr/

noun … “Software embedded in hardware.”

Firmware is specialized software stored in non-volatile memory, such as ROM or Flash, that provides low-level control for a device’s hardware. It acts as an intermediary between the hardware and higher-level software, enabling the system to initialize, configure, and operate correctly. Firmware is essential in embedded systems, computers, networking devices, and peripherals.

Key characteristics of Firmware include:

• Non-volatility: retains instructions even when the device is powered off.
• Hardware-specific: tightly coupled with device architecture and components.
• Updateable: modern firmware can often be upgraded to fix bugs, improve performance, or add features.
• Essential startup role: firmware often contains bootloaders that initialize hardware and load operating systems.
• Security implications: compromised firmware can create persistent vulnerabilities, requiring careful update mechanisms.

Workflow example: Booting a computer:

function power_on() {
    firmware.initialize_hardware()
    firmware.perform_self_test()
    os = firmware.load_os("RAM")
    cpu.execute(os)
}

Here, firmware initializes the hardware, conducts diagnostics, loads the operating system into RAM, and hands control to the CPU.

Conceptually, Firmware is like the embedded instructions in a smart appliance: it ensures the device knows how to start, operate, and interact with other components before any user-level software takes control.

See ROM, Flash, Memory, Bootloader, CPU.

/flæʃ/

noun … “Non-volatile memory with electrical erase and write.”

Flash is a type of non-volatile memory that can be electrically erased and reprogrammed. Unlike traditional ROM, Flash supports multiple write and erase cycles, making it suitable for storage devices like SSDs, USB drives, and embedded systems. It combines the speed of semiconductor memory with persistent data retention, bridging the gap between volatile RAM and slower mechanical storage.

Key characteristics of Flash memory include:

• Non-volatility: retains data without power.
• Block-based erase: memory is erased in large blocks before being rewritten.
• Limited write endurance: each cell can endure a finite number of program/erase cycles, requiring wear-leveling strategies.
• Fast read operations: often much quicker than mechanical storage, though slower than SRAM or DRAM.
• Integration: used in SSDs, microcontrollers, smartphones, and other embedded devices.

Workflow example: Writing data to an SSD using Flash:

function write_flash(address, data) {
    if block at address not empty:
        erase_block(address)
    program_block(address, data)
}

Here, a block must be erased before new data is programmed, reflecting the block-oriented nature of Flash. Wear-leveling algorithms distribute writes to maximize lifespan.

Conceptually, Flash is like a reusable sticky note: you can write, erase, and rewrite information repeatedly, and it retains the latest note even when the power is off.

See ROM, Memory, SSD, Wear Leveling, EEPROM.

/kæʃ/

noun … “Fast memory for frequently used data.”

Cache is a high-speed memory layer that stores copies of frequently accessed data to reduce access latency and improve overall system performance. It acts as an intermediary between slower main memory (e.g., RAM) or storage and the CPU, allowing repeated reads and writes to be served quickly. Caches are used in hardware (CPU caches, GPU caches), software (database query caching), and networking (CDN caches).

Key characteristics of Cache include:

• Speed: typically implemented with faster memory types (e.g., SRAM) to minimize latency.
• Hierarchy: CPU caches are often divided into levels—L1 (smallest, fastest), L2, and L3 (larger, slightly slower).
• Locality: cache efficiency relies on temporal and spatial locality, predicting which data will be reused.
• Coherency: ensures cached data is synchronized with main memory to prevent stale reads.
• Eviction policies: strategies like LRU (Least Recently Used) decide which entries are replaced when the cache is full.

Workflow example: When a CPU requests data:

function read_data(address) {
    if cache.contains(address):
        return cache.get(address)  -- Fast access
    else:
        data = RAM.read(address)
        cache.update(address, data)
        return data
}

Here, the cache checks for the requested data. If present, it returns the value quickly. If not, it retrieves data from slower RAM and updates the cache for future access.

Conceptually, Cache is like keeping frequently referenced documents on your desk instead of fetching them from a filing cabinet every time—you trade a small amount of space for significant speed and convenience.

See Memory, RAM, CPU, GPU, Cache Coherency.

/roʊm/

noun … “Non-volatile storage for permanent instructions.”

ROM (Read-Only Memory) is a type of non-volatile memory used to store data or program instructions that must persist even when the system is powered off. Unlike volatile memory such as RAM, contents of ROM are typically fixed at manufacturing or written once and rarely modified. ROM is commonly used to hold firmware, bootloaders, and essential system-level instructions required to start and initialize hardware.

Key characteristics of ROM include:

• Non-volatility: retains data permanently without power.
• Limited write capability: often written once (e.g., mask ROM) or modified through specialized processes (e.g., EEPROM, flash ROM).
• Bootstrapping: contains critical instructions that allow a system to initialize hardware and load an operating system.
• Reliability: less prone to accidental modification or corruption compared to volatile memory.
• Integration: frequently embedded in motherboards, embedded devices, and microcontrollers.

Workflow example: During system startup, the CPU reads instructions from ROM to initialize hardware components and configure memory before transferring control to the operating system loaded into RAM:

-- Simplified boot sequence
cpu.fetch("ROM:Bootloader")
bootloader.initialize_hardware()
bootloader.load_os("RAM")

Conceptually, ROM is like a sealed instruction manual permanently attached to a machine. No matter how many times the machine is powered off and on, the manual is always available to guide its startup and operation.

See Memory, RAM, Flash Memory, Firmware, CPU.

/ˈmɛməri/

noun … “Storage for data and instructions.”

Memory is the component or subsystem in a computing environment responsible for storing and retrieving data and program instructions. It encompasses volatile storage such as RAM, non-volatile storage like ROM, and other forms including cache, registers, and persistent memory. Effective memory management is critical for performance, multitasking, and ensuring data integrity across CPU operations.

Key characteristics of Memory include:

• Volatility: volatile memory loses data when power is removed (e.g., RAM), while non-volatile memory retains it (e.g., ROM, SSDs).
• Hierarchy: memory is structured in layers, including registers, caches, main memory, and secondary storage, balancing speed and capacity.
• Addressability: each memory location has a unique address used by the CPU to read or write data.
• Access time: memory types differ in latency and bandwidth, influencing overall system performance.
• Persistence and durability: persistent memory retains state across power cycles, supporting file systems and databases.

Workflow example: In a typical program, data is loaded from persistent storage into RAM for computation. The CPU accesses instructions and variables from memory, often leveraging cache to minimize latency:

int main() {
    int x = 42  -- Stored in RAM or CPU register
    int y = x * 2
    std::cout << "Result: " << y << std::endl
}

Here, Memory holds the variables x and y, while instructions execute from memory locations accessible to the CPU.

Conceptually, Memory is like a library where books (data) are stored and retrieved by readers (the CPU) when needed. Fast access to frequently used books improves efficiency, while less-used volumes may reside in the stacks.

See RAM, ROM, CPU, Cache, Memory Management.