Computing

/ˈɛ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.

/wɛər ˈlɛvəlɪŋ/

noun … “Evenly distribute writes to prolong memory lifespan.”

Wear Leveling is a technique used in non-volatile memory devices, such as Flash storage and SSDs, to prevent certain memory blocks from wearing out prematurely due to repeated program/erase cycles. Flash memory cells have a limited number of write cycles, and wear leveling distributes writes across the device to ensure all blocks age uniformly, extending the effective lifespan of the storage.

Key characteristics of Wear Leveling include:

• Static wear leveling: redistributes infrequently used blocks to balance usage across all memory cells.
• Dynamic wear leveling: monitors active write operations and directs them to less-used blocks.
• Longevity optimization: prevents early failure of hot spots by ensuring uniform usage.
• Transparency: usually handled by the memory controller, making it invisible to the host system or software.
• Integration: often combined with ECC and bad block management for reliability.

Workflow example: Writing data to an SSD:

function write_data(logical_address, data) {
    physical_block = wear_leveling.select_block(logical_address)
    flash.erase(physical_block)
    flash.program(physical_block, data)
}

Here, the wear leveling algorithm selects a physical block that has experienced fewer writes, erases it, and programs the new data, ensuring uniform wear across the device.

Conceptually, Wear Leveling is like rotating tires on a vehicle: by periodically moving high-use areas to different positions, the overall lifespan is extended, preventing some parts from wearing out too quickly.

See Flash, Memory, SSD, ECC, Non-Volatile Memory.

/ˈɡɑːrbɪdʒ kəˈlɛkʃən/

noun … “Automatic memory reclamation.”

Garbage Collection is a runtime process in programming languages that automatically identifies and reclaims memory occupied by objects that are no longer reachable or needed by a program. This eliminates the need for manual deallocation and reduces memory leaks, particularly in managed languages like Java, C#, and Python. Garbage collection works closely with heap memory, tracking allocations and references to determine which memory blocks can be safely freed.

Key characteristics of Garbage Collection include:

• Automatic reclamation: memory is freed without explicit instructions from the programmer.
• Reachability analysis: objects are considered “garbage” if there are no references from live code.
• Strategies: multiple algorithms exist, such as reference counting, mark-and-sweep, generational, and incremental collection.
• Performance impact: garbage collection introduces overhead, often mitigated by optimizing collection frequency or using concurrent collectors.
• Interaction with heap: works on dynamically allocated memory, ensuring efficient memory usage and reducing fragmentation.

Workflow example: In Java-like pseudocode:

function main() {
    obj = new Object()      -- Allocate memory on heap
    obj = null              -- Remove reference
    -- Garbage collector identifies obj as unreachable and frees its memory
}

Here, once obj has no remaining references, the garbage collector can reclaim the memory automatically, preventing leaks and optimizing resource usage.

Conceptually, Garbage Collection is like a janitor in a library who periodically removes books that are no longer referenced or in use, ensuring the shelves (heap) remain organized and available for new material.

See Heap, Memory Management, Memory, Reference Counting, Stack.

/hiːp/

noun … “Dynamic memory area for runtime allocation.”

Heap is a region of memory used for dynamic allocation, where programs request and release blocks of memory at runtime rather than compile-time. Unlike the stack, which operates in a last-in, first-out manner, the heap allows arbitrary allocation sizes and lifetimes. Proper management of the heap is crucial to prevent fragmentation, leaks, and performance degradation.

Key characteristics of Heap include:

• Dynamic allocation: memory can be requested and released at runtime using functions like malloc and free (C/C++), or via garbage collection in managed languages.
• Non-linear access: blocks can be allocated and freed in any order.
• Persistence: allocated memory remains valid until explicitly freed or reclaimed by a garbage collector.
• Fragmentation: improper management can lead to gaps between allocated blocks, reducing usable memory.
• Interaction with pointers: in low-level languages, heap memory is accessed via references or pointers.

Workflow example: Allocating and using heap memory in C++:

int* array = (int*) malloc(10 * sizeof(int))  -- Allocate 10 integers on the heap
for int i = 0..9:
    array[i] = i * 2
free(array)  -- Release memory back to the heap

Here, heap memory is dynamically allocated, used, and then explicitly freed to prevent leaks. In languages with automatic garbage collection, the runtime handles reclamation.

Conceptually, Heap is like a communal storage area where items can be placed and retrieved in any order, as opposed to a stack of plates where only the top plate is accessible at any time.

See Memory, Stack, Memory Management, Garbage Collection, Pointer.

/kæʃ koʊˈhɪərəns/

noun … “Keeping multiple caches in sync.”

Cache Coherency is the consistency model ensuring that multiple copies of data in different caches reflect the same value at any given time. In multiprocessor or multi-core systems, each CPU may have its own cache, and maintaining coherency prevents processors from operating on stale or conflicting data. Cache coherency is critical for correctness in concurrent programs and high-performance systems.

Key characteristics of Cache Coherency include:

• Write propagation: changes to a cached value must propagate to other caches or main memory.
• Transaction serialization: read and write operations appear in a consistent order across processors.
• Protocols: hardware or software protocols like MESI (Modified, Exclusive, Shared, Invalid) manage coherency efficiently.
• Latency vs. correctness: strict coherency ensures correctness but can introduce delays; relaxed models trade consistency for performance.
• Multi-level consideration: coherency must be maintained across all cache levels (L1, L2, L3) and sometimes across multiple systems in distributed memory setups.

Workflow example: In a multi-core system:

Core1.cache.write(address, 42)
Core2.cache.read(address)  -- Protocol ensures Core2 sees 42 or waits until propagation completes
Memory[address] = 42       -- Main memory updated after caches synchronize

Here, a write to Core1’s cache is propagated according to the coherency protocol so that Core2 and main memory remain consistent.

Conceptually, Cache Coherency is like multiple chefs sharing copies of a recipe: when one chef updates an ingredient or instruction, all other chefs must see the same update to avoid cooking conflicting dishes.

See Cache, CPU, Multiprocessing, Memory, Concurrency.

/ˈ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.