Protocol

/ˌɛm.kjuːˌtiːˈtiː/

noun — "lightweight messaging protocol for IoT devices."

MQTT , short for Message Queuing Telemetry Transport, is a lightweight, publish-subscribe messaging protocol optimized for constrained devices and low-bandwidth, high-latency, or unreliable networks. It enables efficient, asynchronous communication between clients and brokers, making it widely used in Internet of Things (IoT) applications.

Technically, MQTT operates over TCP/IP and defines three types of Quality of Service (QoS) levels: at-most-once, at-least-once, and exactly-once. Messages are published to topics, and subscribers receive messages from topics they are interested in. The protocol uses a small header (just 2 bytes for most messages), minimizing overhead and allowing reliable messaging even on limited hardware.

An MQTT system consists of clients (publishers and subscribers) and a broker. Publishers send messages to topics on the broker, which manages delivery to subscribers. The broker can retain messages for new subscribers, support persistent sessions, and handle thousands of concurrent connections efficiently.

In workflow terms, a temperature sensor in a smart home might publish readings to a topic named home/temperature. Multiple subscribers, such as a monitoring dashboard, an alerting system, or a logging service, receive the readings independently and in near real-time. Publishers and subscribers are decoupled, allowing each component to scale or fail without impacting the others.

Conceptually, MQTT is a minimalist switchboard for device-to-device messaging, designed to keep communication reliable, low-overhead, and asynchronous across large networks of sensors and actuators.

See Pub/Sub, Streaming, Kafka.

/ˈkɑːfkə/

noun — "high-throughput distributed event streaming platform."

Kafka is a distributed event streaming platform designed for high-throughput, fault-tolerant, and scalable messaging. It implements a **publish-subscribe** model where producers publish messages to topics, and consumers subscribe to those topics to receive messages asynchronously. This architecture decouples producers and consumers, enabling independent scaling and real-time data processing across distributed systems.

Technically, Kafka consists of brokers, topics, partitions, producers, and consumers. Messages are stored in **append-only logs** partitioned across brokers. Partitions provide parallelism and ordering guarantees, while replication ensures durability and fault tolerance. Consumers maintain offsets to track their progress, allowing replay and exactly-once or at-least-once processing semantics.

Kafka supports streaming pipelines where data flows continuously from sources to sinks. Producers push structured or unstructured events, the Kafka cluster persists them reliably, and consumers process these events in real-time. It integrates with stream processing frameworks, such as Kafka Streams, Flink, and Spark Streaming, to perform transformations, aggregations, or analytics on live data.

In workflow terms, a web application might publish user activity events to Kafka topics. Multiple downstream services consume these events: one updates a recommendation engine, another logs analytics metrics, and a third triggers notifications. Each service scales independently and can replay events as needed, without disrupting producers or other consumers.

Conceptually, Kafka acts as a durable, distributed, and ordered message bus for streaming data. It functions as the backbone for real-time analytics, event-driven architectures, and scalable microservices ecosystems.

See Streaming, Pub/Sub, MQTT.

/pʌb ˈsʌb/

noun — "asynchronous messaging model for decoupled communication."

Pub/Sub (short for Publish/Subscribe) is a messaging pattern in which senders (publishers) do not send messages directly to specific receivers (subscribers), but instead categorize messages into channels or topics. Subscribers express interest in one or more topics and receive only messages that match those topics. This decouples the sender and receiver, enabling scalable, asynchronous communication across distributed systems.

Technically, a Pub/Sub system consists of three core components: the publisher, the subscriber, and the message broker. Publishers push messages to the broker, which handles routing based on topic subscriptions. Subscribers register interest in topics, and the broker ensures delivery, either immediately or via persistent queues. This mechanism supports both transient and durable subscriptions depending on system requirements.

Common implementations include cloud messaging services like Google Cloud Pub/Sub, Kafka (when used in pub/sub mode), and MQTT brokers. Messages may carry structured payloads in formats such as JSON, Protocol Buffers, or Avro. Delivery semantics vary by system: at-most-once, at-least-once, or exactly-once guarantees, affecting reliability and idempotency considerations.

In workflow terms, a sensor network might publish telemetry data to a topic like temperature-readings. Multiple processing services subscribe to this topic: one logs the readings, another triggers alerts if thresholds are exceeded, and another aggregates metrics. None of these services need direct knowledge of each other, and the publisher does not need to know the number of subscribers.

Pub/Sub is often paired with streaming systems for real-time event handling. Publishers continuously generate events, brokers buffer and route them, and subscribers process events asynchronously. This allows scaling out consumers independently, supporting high-throughput, low-latency architectures common in microservices and IoT ecosystems.

Conceptually, Pub/Sub acts as a message switchboard: publishers deposit messages at labeled slots (topics), and subscribers pull from slots they care about. This abstraction simplifies complex, distributed communication patterns, promotes loose coupling, and allows systems to evolve independently without breaking contracts between producers and consumers.

See Streaming, MQTT, Kafka.

/ræft/

noun … “Simplified consensus algorithm for distributed systems.”

Raft is a fault-tolerant Consensus algorithm designed to manage a replicated log in a Distributed System. Raft ensures that multiple nodes agree on a sequence of state changes, providing strong consistency and simplifying the complexity associated with other consensus protocols like Paxos. It is widely used in distributed databases, configuration services, and fault-tolerant systems.

Key characteristics of Raft include:

• Leader-based approach: one node acts as a leader, coordinating log replication and client requests.
• Log replication: the leader appends commands to its log and ensures follower nodes replicate the same entries in order.
• Election and fault tolerance: if the leader fails, a new leader is elected among followers using randomized timers to avoid conflicts.
• Safety: all committed entries are guaranteed to be durable and consistent across all non-faulty nodes.
• Simplicity: Raft separates leader election, log replication, and safety mechanisms to make understanding and implementation more straightforward than Paxos.

Workflow example: In a distributed key-value store using Raft, a client submits a write operation. The current leader appends the operation to its log, then sends append entries requests to follower nodes. Once a majority of followers acknowledge the entry, it is considered committed, and the leader applies it to its local state machine. Followers apply the entry once committed. If the leader crashes, a new leader is elected and resumes log replication without violating consistency.

-- Simplified Raft log replication
leader = "Node1"
followers = ["Node2", "Node3"]
entry = "Set X = 42"
leader_log.append(entry)
for follower in followers {
    send_append_entries(follower, entry)
}
if majority_acknowledged(followers, entry):
    commit(entry)
}
-- All nodes eventually apply the committed entry

Conceptually, Raft is like a conductor leading an orchestra: the leader ensures all musicians follow the same sheet of music in sync. If the conductor is unavailable, the orchestra quickly elects a new conductor to continue performing without missing a beat.

See Consensus, Paxos, Distributed Systems, Replication, CAP Theorem.

/ˈpæk.sɒs/

noun … “Consensus algorithm for unreliable networks.”

Paxos is a fault-tolerant Consensus algorithm designed to achieve agreement among nodes in a Distributed System, even when some nodes fail or messages are delayed or lost. It ensures that a single value is chosen and consistently replicated across all non-faulty nodes, providing a foundation for reliable state machines, replicated databases, and coordination services.

Key characteristics of Paxos include:

• Roles: nodes operate as Proposers (suggest values), Acceptors (vote on values), and Learners (learn the agreed value).
• Quorum-based decisions: a value is chosen only when a majority of acceptors agree, ensuring safety despite node failures.
• Safety: at most one value can be chosen, preventing conflicting decisions.
• Liveness: the algorithm guarantees progress if a sufficient number of nodes are operational and communication is eventually reliable.
• Fault tolerance: works correctly even if some nodes crash or messages are delayed, provided a majority of acceptors remain reachable.

Workflow example: In a distributed key-value store, when a client proposes a new value for a key, Proposers send prepare requests to Acceptors. Acceptors respond with promises to reject lower-numbered proposals. Once a majority agree, the value is accepted and propagated to Learners, ensuring all non-faulty nodes converge on the same value.

-- Simplified Paxos prepare phase
proposers = ["P1", "P2"]
acceptors = ["A1", "A2", "A3"]
proposal_number = 1
for proposer in proposers {
    for acceptor in acceptors {
        send_prepare(acceptor, proposal_number)
    }
}
-- Acceptors respond with promise to ignore lower-numbered proposals

Conceptually, Paxos is like a committee that must choose a single candidate among several options. Even if some members are absent or communication is delayed, the committee follows a strict protocol to ensure only one candidate is elected, and all members eventually learn the result.

See Consensus, Raft, Distributed Systems, Replication, CAP Theorem.

/ˈwaɪˌfʌɪ ˈlæn/

noun — "a local network that connects devices wirelessly."

WLAN, short for Wireless Local Area Network, is a network that allows devices such as computers, smartphones, and IoT (IoT) devices to communicate and share resources without physical cables. WLANs use radio waves to transmit data, typically following IEEE 802.11 standards, and provide the flexibility and mobility that wired LANs cannot offer.

Technically, a WLAN consists of access points that broadcast wireless signals, and client devices that connect to these points using wireless adapters. Security mechanisms like WPA3 encryption, authentication, and MAC filtering protect data transmitted over the air. WLANs support various topologies, including infrastructure mode (devices connect through an access point) and ad hoc mode (devices connect directly to each other).

Key characteristics of WLANs include:

• Wireless connectivity: eliminates the need for physical cabling between devices.
• Mobility: allows users to move freely while staying connected.
• Protocol-driven: based on IEEE 802.11 standards, with versions like 802.11n, 802.11ac, and 802.11ax.
• Security features: encryption and authentication protect data integrity and privacy.
• Integration with LAN: often extends or bridges wired LAN networks to wireless devices.

In practical workflows, WLANs enable employees, students, or users in public spaces to access shared resources, connect to the Internet, and interact with applications wirelessly. Network engineers manage channel assignments, signal strength, and security settings to ensure reliable, high-speed connectivity across coverage areas.

Conceptually, a WLAN is like an invisible local highway system, allowing devices to travel and exchange data freely without wires.

Intuition anchor: WLANs provide the freedom and flexibility of mobility while maintaining the speed and functionality of a local network.

Related links include LAN, IoT, and IP.

/ˌlɒk.əl ˈɛəˌnet/

noun — "a local network connecting devices in a limited area."

LAN, short for Local Area Network, is a network that interconnects computers, servers, and devices within a limited geographic area, such as a home, office, or campus. LANs enable high-speed data exchange, resource sharing, and collaborative communication between connected devices. They are foundational to enterprise computing, gaming setups, and smart building infrastructures.

Technically, LANs use wired technologies like Ethernet (IEEE 802.3) or wireless protocols such as Wi-Fi (IEEE 802.11). Devices are connected through switches or access points, often with a central router providing access to broader networks or the Internet (Internet). LANs employ addressing schemes via IP for identifying devices, and communication can occur using protocols like TCP/IP (TCP/IP) or UDP (UDP) for reliable and real-time data exchange.

Key characteristics of LANs include:

• Limited geographic scope: typically confined to a single building or campus.
• High bandwidth: supports fast communication and low latency between devices.
• Centralized management: switches, routers, and access points coordinate traffic efficiently.
• Resource sharing: enables printers, storage, and applications to be accessed by multiple devices.
• Scalability: can grow with additional devices and network segments within the area.

In practical workflows, LANs support internal email servers, file sharing, VoIP, video conferencing, and gaming. Network administrators monitor traffic, enforce security policies, and manage IP addressing to maintain reliable and secure operation. Wireless LANs (WLAN) provide mobility for laptops, smartphones, and IoT (IoT) devices while maintaining the same network functionality.

Conceptually, a LAN is like a local road network inside a city: fast, efficient, and controlled, allowing people and goods (data) to move seamlessly between points.

Intuition anchor: LANs connect devices within a confined space, creating the high-speed internal backbone of digital environments.

See WLAN, IP, and Internet.

/ˈɪn.tər.net/

noun — "the global web of interconnected networks carrying data worldwide."

Internet is the massive system of interconnected IP-based networks that allows computers, servers, mobile devices, and other nodes to communicate and share information globally. It functions as a decentralized network of networks, enabling data exchange, web services, email, streaming, and countless other digital applications. The Internet relies on standardized protocols, addressing schemes, and routing mechanisms to move information reliably between endpoints.

Technically, the Internet is built upon the Internet Protocol suite, primarily IP for addressing and TCP and UDP for transport. Routers, switches, and gateways manage the flow of packets through complex topologies, ensuring data reaches its intended destination. Domains and DNS (Domain Name System) provide human-readable addressing, while backbone networks connect regional ISPs to maintain global reach. Security layers like TLS/SSL, VPNs (VPN), and firewalls protect data integrity, privacy, and network availability.

Key characteristics of the Internet include:

• Global connectivity: links billions of devices across continents and networks.
• Protocol-driven: standardized rules like IP, TCP, and HTTP coordinate communication.
• Scalable architecture: supports growth from local networks to worldwide infrastructure.
• Decentralization: no single entity controls the entire network, enabling resilience and distributed access.
• Multipurpose functionality: carries data for web browsing, email, streaming, IoT (IoT), cloud services, and more.

In practical workflows, the Internet allows users to request resources from servers, transmit data between applications, and connect devices remotely. Network engineers design, maintain, and optimize routing, peering, and bandwidth to ensure efficient operation. Cybersecurity measures protect against threats like spoofing, DDoS attacks, and data breaches, preserving the reliability and trustworthiness of online interactions.

Conceptually, the Internet is like a vast, invisible transportation network: devices are stations, data packets are vehicles, and protocols are traffic laws ensuring smooth delivery worldwide.

Intuition anchor: the Internet is the digital backbone of modern communication, linking devices, services, and people across the globe.

Related links include IP, TCP, and VPN.

/ˈnɛt.wɜːrk/

noun — "the web of connected devices exchanging data."

Network is a system of interconnected devices, nodes, or computers that communicate and share resources through wired or wireless links. Networks can range from small local setups, such as Local Area Networks (LAN), to expansive global structures like the Internet. They enable resource sharing, distributed computing, data transfer, and communication between users and devices.

Technically, a network consists of nodes (computers, servers, routers, switches), transmission media (copper, fiber, wireless), and communication protocols that define how data is packaged, addressed, transmitted, and received. Common protocols include IP for addressing and routing, TCP/UDP for transport, and higher-level protocols like HTTP, FTP, and DNS for application services. Networks may be structured hierarchically with core, distribution, and access layers to optimize performance, reliability, and scalability.

Key characteristics of networks include:

• Connectivity: enables devices to exchange information over shared links.
• Scalability: can grow from a few nodes to millions of interconnected devices.
• Protocol-driven: communication depends on standardized rules for data exchange.
• Redundancy: alternative paths ensure reliability in case of failures.
• Resource sharing: facilitates access to files, applications, and hardware devices across multiple systems.

In practical workflows, engineers design networks to balance speed, security, and reliability. Routers and switches manage traffic flow, while firewalls and intrusion detection systems protect against unauthorized access. Wireless networks employ encryption protocols and authentication methods to secure communication. Enterprise and cloud networks often integrate LAN, Wide Area Networks (WAN), and Virtual Private Networks (VPN) to provide secure, flexible connectivity for users and applications.

Conceptually, network is like a transportation system: devices are stations, data packets are vehicles, and protocols are traffic rules ensuring smooth and reliable movement across the system.

Intuition anchor: networks are the invisible highways of digital communication, connecting devices and enabling the flow of information across distances.

Related links include IP, LAN, and VPN.

/ˌɛs ˌdiː ˈeɪ/

noun — "the line that carries data bit by bit in serial communication."

SDA (Serial Data) is the signal line used in serial communication protocols, most commonly in I²C (I2C) interfaces, to transmit and receive data between devices. Unlike parallel communication, where multiple bits are sent simultaneously over multiple lines, serial communication transmits one bit at a time, reducing wiring complexity and enabling communication over longer distances. The SDA line carries the actual data payload, while a complementary clock line, typically SCL (Serial Clock), synchronizes the timing of each bit.

Technically, SDA is an open-drain or open-collector line, requiring external pull-up resistors to maintain a high logic level when no device is driving the line low. Devices connected to the bus use defined voltage levels to represent logical 0 and 1. During communication, data is transmitted sequentially, with each bit being valid on a specific clock edge defined by the protocol. SDA supports multi-master and multi-slave configurations in I²C, allowing multiple devices to share the same bus efficiently while implementing collision detection and arbitration mechanisms.

Key characteristics of SDA include:

• Serial transmission: data is sent one bit at a time, simplifying wiring.
• Open-drain signaling: requires pull-up resistors and allows multiple devices to drive the line safely.
• Synchronization: tightly coupled with the clock line (SCL) for accurate data timing.
• Bidirectional capability: supports both sending and receiving data on the same line.
• Protocol dependent: behavior is governed by standards like I²C, SMBus, or PMBus.

In practical workflows, engineers use the SDA line to transmit sensor readings, control commands, or configuration data between microcontrollers and peripheral devices. During an I²C transaction, the master device generates clock pulses on SCL, while data bits are placed on or read from SDA. Proper timing, voltage levels, and bus arbitration are critical to prevent data corruption, especially in multi-device setups.

Conceptually, SDA is like a single-lane bridge for digital communication: each bit crosses one at a time, but with precise timing and coordination, the full message travels reliably from source to destination.

Intuition anchor: SDA carries the lifeblood of serial communication, enabling devices to exchange information efficiently over a minimal number of wires.

Related links include I2C and SCL.