Hardware

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

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

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

/ænˈtɛnə/

noun … “Device that converts electrical signals to radio waves and back.”

Antenna is a transducer used in radio and wireless communication systems to convert electrical signals into electromagnetic waves for transmission, or to receive electromagnetic waves and convert them back into electrical signals. It serves as the critical interface between a Radio transmitter or receiver and free space, enabling communication without physical conductors.

Key characteristics of Antenna include:

• Resonant frequency: the frequency or range of frequencies at which the antenna efficiently radiates or receives energy.
• Radiation pattern: the spatial distribution of radiated power, often visualized as directional or omnidirectional lobes.
• Gain: a measure of how effectively the antenna directs energy compared to a reference isotropic radiator.
• Impedance matching: ensures maximum power transfer between the antenna and the transmitter or receiver circuitry.
• Polarization: orientation of the electric field vector, affecting compatibility with other antennas and signal propagation.

Workflow example: In a cellular base station, a transmitter outputs an electrical signal encoding voice or data. The antenna converts this signal into radio waves that propagate through the environment. A mobile device with a compatible antenna captures a portion of this energy, converts it back into an electrical signal, and decodes the information. System designers carefully select antenna type, orientation, and placement to maximize coverage, reduce interference, and optimize link reliability.

-- Example: simple dipole antenna parameters
frequency = 2.4e9        -- 2.4 GHz
wavelength = 3e8 / frequency
length = wavelength / 2  -- half-wave dipole
gain = 2.15               -- dBi for standard dipole
print("Antenna length: " + str(length) + " meters, Gain: " + str(gain))

Conceptually, an antenna is like the mouth and ears of a communication system: it speaks by radiating energy into space and listens by capturing faint signals, translating between the language of electrons and the language of waves.

See Radio, Modulation, Signal-to-Noise Ratio, Wavelength, Gain.

/swɪtʃ/

noun — "the network’s smart connector that keeps data flowing to the right place."

Switch is a network device that connects multiple devices within a LAN and forwards data frames only to the intended destination device, improving efficiency and reducing collisions compared to hubs. Switches operate at the data link layer (Layer 2) and can also function at the network layer (Layer 3) for routing capabilities.

Technically, a Switch maintains a MAC address table to map devices and ports, ensuring data is delivered accurately and efficiently. Advanced switches support VLANs, QoS (QoS), link aggregation, and port security, enabling traffic prioritization and network segmentation for better performance and security.

Key characteristics of Switches include:

• Frame forwarding: sends data only to the correct device based on MAC addresses.
• VLAN support: segments networks for improved management and security.
• Traffic management: includes QoS and link aggregation for efficiency.
• Security: can enforce port-level security and prevent unauthorized access.
• Scalability: connects multiple devices without degrading performance.

In practical workflows, switches are deployed in offices, data centers, and homes to connect computers, printers, servers, and access points, managing local traffic and optimizing bandwidth usage.

Conceptually, a Switch is like a mail sorter, directing each piece of data to the correct mailbox instead of broadcasting to everyone.

Intuition anchor: Switch ensures data reaches exactly where it needs to go efficiently.

See LAN, QoS, VLAN, Router, MAC.