# Communication protocol ## Microsim ### Live player <div class="microsim-player"> <iframe src="https://editor.p5js.org/sciencenibber/full/nxpBw5EQr" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe> </div> <div class="microsim-fallback"> <img src="Microsims/thumbs/Communication_protocol.png" alt="Communication_protocol microsim poster" style="width:100%;border:1px solid #4445;border-radius:6px;"> <p><em>Live microsim (desktop) · <a href="https://editor.p5js.org/sciencenibber/sketches/nxpBw5EQr">open sketch in the p5.js editor</a></em></p> </div> **Editor URL:** https://editor.p5js.org/sciencenibber/sketches/nxpBw5EQr **Description (100 words):** This microsim animates Stop-and-Wait ARQ, the simplest reliable communication protocol, as a space-time diagram: time runs downward between a sender and receiver timeline. Each cycle the sender transmits one frame (blue parallelogram) that propagates to the receiver, which returns an acknowledgement (orange) before the next frame is sent. The slider a sets the propagation-to-transmission ratio t_prop/t_frame; the slider p sets the channel's frame-loss probability. Lost frames get no ACK, time out (red, dashed), and are retransmitted. Live readouts compare the theoretical link efficiency eta = (1 - p) / (1 + 2a) against an empirical efficiency the simulation accumulates as it runs. ```js // ===================================================================== // Article : Communication protocol // Slug : Communication_protocol // Wikitube : en.wikitube.io/wiki/Communication_protocol // Room : Audio // // Idea : A communication protocol is the set of rules two parties // follow to exchange information reliably over an imperfect // channel. The defining feature of a *reliable* protocol is // acknowledgement + retransmission: the sender keeps a copy // of each frame until the receiver confirms it, and resends // on timeout. This sketch animates the canonical example, // Stop-and-Wait ARQ, as a space-time (sender | receiver) // diagram. Time runs downward; a frame travels down-right to // the receiver, an ACK travels down-left back to the sender, // and only then is the next frame sent. A slider sets the // channel's frame-loss probability p; lost frames get no ACK, // time out (drawn red, dashed), and are retransmitted. // // Parameters // a = t_prop / t_frame propagation-to-transmission ratio (the // single number that governs link efficiency) // p = frame loss prob. probability a frame (or its ACK) is lost // spd = animation speed cosmetic; does not change the protocol // // Equation : Link efficiency of Stop-and-Wait ARQ with frame errors: // // eta = (1 - p) / (1 + 2a), a = t_prop / t_frame // // The 1 is the time spent putting one frame on the wire; // the 2a is the round trip the sender must wait for the ACK. // With losses, only a fraction (1 - p) of attempts succeed, // so useful throughput scales by (1 - p). The sketch also // accumulates an *empirical* efficiency from the simulated // run so the reader can watch it converge on the formula. // ===================================================================== // Rule §3 — single source of truth for the title / URL / save-name. const ARTICLE = "Communication_protocol"; // Rule §4 — disable the Friendly Error System for ship. p5.disableFriendlyErrors = true; // --------------------------------------------------------------------- // Globals // --------------------------------------------------------------------- let aSlider; // a = t_prop / t_frame let pSlider; // frame-loss probability let spdSlider; // animation speed multiplier // Space-time diagram layout (computed in setup from width/height). let SX, RX; // x of the sender and receiver timelines let TY, BY; // top and bottom y of the time axis // Per-cycle animation state. let cyclePhase = 0; // 0..1 progress through the current cycle let curLost = false; // did this cycle's frame get lost? let cycleIsAck = true;// does this cycle end in an ACK (success)? // Running statistics for the empirical efficiency readout. let attempts = 0; // total cycles started (incl. retransmissions) let delivered = 0; // frames actually acknowledged let totalTime = 0; // accumulated channel time (in t_frame units) let usefulTime = 0; // accumulated time that delivered a frame // Accent palette (rule §8) — at most three accents. const C_FRAME = [40, 90, 200]; // blue : frame in flight const C_ACK = [220, 130, 40]; // orange : acknowledgement const C_LOSS = [220, 60, 60]; // red : lost frame / timeout // --------------------------------------------------------------------- // setup // --------------------------------------------------------------------- function setup() { createCanvas(720, 520); // rule §5 — standard canvas size pixelDensity(2); // crisp text on retina // Diagram geometry, derived from the canvas so nothing is hardcoded. SX = 200; // sender timeline x RX = width - 170; // receiver timeline x TY = 120; // top of the time axis BY = height - 90; // bottom of the time axis // Controls (rule §6) — built once, here, with meaningful ranges. // a from 0.1 (frame much longer than the hop) to 5 (long fat link). aSlider = createSlider(0.1, 5, 1, 0.1); aSlider.position(150, height - 56); aSlider.style("width", "150px"); // p from a perfect channel (0) to a very lossy one (0.5). pSlider = createSlider(0, 0.5, 0.1, 0.01); pSlider.position(150, height - 34); pSlider.style("width", "150px"); // Cosmetic animation speed. spdSlider = createSlider(0.2, 3, 1, 0.1); spdSlider.position(440, height - 34); spdSlider.style("width", "110px"); startCycle(); // prime the first cycle } // Begin a fresh cycle: roll the dice for loss, reset the phase. function startCycle() { cyclePhase = 0; const p = pSlider.value(); curLost = random() < p; // this frame (or its ACK) is lost cycleIsAck = !curLost; // success cycles end in an ACK } // --------------------------------------------------------------------- // draw // --------------------------------------------------------------------- function draw() { background(250); const a = aSlider.value(); const p = pSlider.value(); // One no-loss cycle lasts t_frame + 2*t_prop = 1 + 2a (in t_frame // units). A lost cycle lasts until the timeout, which a sane sender // sets to about one round trip, so we use the same duration. const cycleDur = 1 + 2 * a; // Advance the cycle. The phase sweeps 0..1; speed is cosmetic. cyclePhase += (deltaTime / 1000) * 0.35 * spdSlider.value(); if (cyclePhase >= 1) { // Cycle finished — bank the statistics, then start the next one. attempts += 1; totalTime += cycleDur; if (cycleIsAck) { delivered += 1; usefulTime += 1; // one frame's worth of useful time } startCycle(); } drawDiagram(a); // reference + active geometry drawHUD(a, p); // watermark / readouts / equation (last) } // --------------------------------------------------------------------- // Diagram — the space-time exchange // --------------------------------------------------------------------- function drawDiagram(a) { const cycleDur = 1 + 2 * a; // Map a protocol time t (in t_frame units, 0..cycleDur) to a y pixel. const tToY = (t) => map(t, 0, cycleDur, TY, BY); // --- Reference geometry (rule §8 layer 1): the two timelines. --- stroke(60); strokeWeight(1.5); line(SX, TY, SX, BY); line(RX, TY, RX, BY); noStroke(); fill(60); textSize(13); textAlign(CENTER, BOTTOM); text("SENDER", SX, TY - 8); text("RECEIVER", RX, TY - 8); // Faint downward "time" arrow between the lanes. stroke(200); strokeWeight(1); const midX = (SX + RX) / 2; line(midX, TY, midX, BY); noStroke(); fill(170); textSize(11); textAlign(CENTER, TOP); text("time", midX, BY + 6); // --- Active geometry (rule §8 layer 2). --- // Frame occupies t in [0, 1] on the sender, then propagates to the // receiver arriving over [a, 1 + a]. Draw it as a parallelogram band. const yFrameTopSender = tToY(0); const yFrameBotSender = tToY(1); const yFrameTopRecv = tToY(a); const yFrameBotRecv = tToY(1 + a); const frameCol = curLost ? C_LOSS : C_FRAME; // Band fill (translucent) so the diagonals read as a moving packet. noStroke(); fill(frameCol[0], frameCol[1], frameCol[2], 45); quad(SX, yFrameTopSender, RX, yFrameTopRecv, RX, yFrameBotRecv, SX, yFrameBotSender); // Leading / trailing edges of the frame. stroke(frameCol[0], frameCol[1], frameCol[2]); strokeWeight(2.5); if (curLost) drawingContext.setLineDash([7, 6]); // dashed when lost line(SX, yFrameTopSender, RX, yFrameTopRecv); line(SX, yFrameBotSender, RX, yFrameBotRecv); drawingContext.setLineDash([]); // Frame label, centred on the band. noStroke(); fill(frameCol[0], frameCol[1], frameCol[2]); textSize(12); textAlign(CENTER, CENTER); push(); const flx = (SX + RX) / 2; const fly = (yFrameTopSender + yFrameBotRecv) / 2; text(curLost ? "FRAME (lost)" : "FRAME", flx, fly - 8); pop(); if (cycleIsAck) { // ACK leaves the receiver at t = 1 + a and arrives at t = 1 + 2a. const yAckRecv = tToY(1 + a); const yAckSender = tToY(1 + 2 * a); stroke(C_ACK[0], C_ACK[1], C_ACK[2]); strokeWeight(2.5); line(RX, yAckRecv, SX, yAckSender); noStroke(); fill(C_ACK[0], C_ACK[1], C_ACK[2]); textSize(12); textAlign(CENTER, CENTER); text("ACK", (SX + RX) / 2, (yAckRecv + yAckSender) / 2 - 8); } else { // No ACK: mark the timeout at the sender at t = cycleDur. const yTimeout = tToY(cycleDur); stroke(C_LOSS[0], C_LOSS[1], C_LOSS[2]); strokeWeight(1.5); drawingContext.setLineDash([3, 4]); line(SX - 18, yTimeout, SX + 18, yTimeout); drawingContext.setLineDash([]); noStroke(); fill(C_LOSS[0], C_LOSS[1], C_LOSS[2]); textSize(11); textAlign(LEFT, CENTER); text("timeout -> retransmit", SX + 24, yTimeout); } // --- Sweep marker: the current protocol time. --- const ySweep = lerp(TY, BY, cyclePhase); stroke(120, 120, 120, 160); strokeWeight(1); line(SX - 40, ySweep, RX + 40, ySweep); noStroke(); fill(120); textSize(10); textAlign(LEFT, CENTER); text("now", RX + 44, ySweep); } // --------------------------------------------------------------------- // HUD — watermark, control hints, readouts, equation (drawn last) // --------------------------------------------------------------------- function drawHUD(a, p) { noStroke(); // 2a. Top-left title block. textAlign(LEFT, TOP); fill(20); textSize(20); text("Communication protocol", 16, 14); fill(110); textSize(12); text("Wikitube microsim - en.wikitube.io/wiki/" + ARTICLE, 16, 40); // 2b. Top-right control hints. textAlign(RIGHT, TOP); fill(110); textSize(11); text("sliders: a (t_prop/t_frame), p (frame loss), speed", width - 14, 14); text("Stop-and-Wait ARQ: send -> ACK -> next; loss -> timeout", width - 14, 30); // 2c. Bottom-left live readouts, in the literature's symbols. const etaTheory = (1 - p) / (1 + 2 * a); const etaEmp = totalTime > 0 ? usefulTime / totalTime : 0; textAlign(LEFT, BOTTOM); textSize(13); fill(C_FRAME[0], C_FRAME[1], C_FRAME[2]); text("a = " + nf(a, 1, 2) + " p = " + nf(p, 1, 2), 16, height - 64); fill(20); text("eta (theory) = " + nf(etaTheory, 1, 3) + " eta (run) = " + nf(etaEmp, 1, 3), 16, height - 46); fill(80); textSize(12); text("delivered " + delivered + " / " + attempts + " attempts", 320, height - 64); // Slider labels (rule §7) — to the left of each slider, right-aligned. textAlign(RIGHT, CENTER); textSize(12); fill(60); text("a", 144, height - 50); text("p", 144, height - 28); text("speed", 434, height - 28); // 2d. Bottom-right equation footer (ASCII only, rule §9). textAlign(RIGHT, BOTTOM); textSize(11); fill(80); text("eta = (1 - p) / (1 + 2a), a = t_prop / t_frame", width - 14, height - 10); } ``` ## Links (Wikipedia order) <!-- injected from _registry/childlinks/Communication_protocol.json (2026-07-30T02:09:12Z) --> `ACM_Computing_Classification_System` · `ARPANET` · `ASCII` · `ASN.1` · `AX.25` · `Abstraction_layer` · `Address_Resolution_Protocol` · `Alexander_Graham_Bell` · `Alfred_Vail` · [[Algorithm]] · [[Algorithmic_efficiency]] · `Almon_Brown_Strowger` · `Amos_Dolbear` · `Analysis_of_algorithms` · `Andrew_S._Tanenbaum` · `Antonio_Meucci` · `AppleTalk` · `Application_layer` · `Application_security` · `Application_software` · [[Artificial_intelligence]] · `Asynchronous_Transfer_Mode` · `Audio_coding_format` · `Augmented_Backus–Naur_form` · [[Augmented_reality]] · `Automata_theory` · `Automated_planning_and_scheduling` · `BITNET` · `Bandwidth_(computing)` · `Beacon` · `Binary_Synchronous_Communications` · `Bluetooth` · `Bob_Braden` · `Byte` · `CYCLADES` · `Cable_protection_system` · `Cable_television` · `Camille_Tissot` · `Cellular_network` · `Charles_Bourseul` · `Charles_Grafton_Page` · `Charles_K._Kao` · `Charles_Sumner_Tainter` · `Charles_Wheatstone` · `Circuit_switching` · `Claude_Chappe` · [[Claude_Shannon]] · `Coaxial_cable` · `Code-division_multiple_access` · `Collision_(telecommunications)` · `Combinatorial_explosion` · `Communicating_sequential_processes` · `Communication` · `Communications_satellite` · [[Communications_system]] · `Computability_theory` · `Computational_biology` · `Computational_chemistry` · `Computational_complexity` · `Computational_complexity_theory` · `Computational_engineering` · `Computational_geometry` · `Computational_intelligence` · `Computational_mathematics` · `Computational_physics` · `Computational_problem` · `Computational_social_science` · `Computer_accessibility` · `Computer_animation` · [[Computer_architecture]] · `Computer_data_storage` · `Computer_graphics` · [[Computer_hardware]] · `Computer_network` · [[Computer_science]] · `Computer_security` · `Computer_vision` · `Computing` · `Computing_platform` · `Concurrency_(computer_science)` · `Concurrent_computing` · `Connection-oriented_communication` · `Contention_(telecommunications)` · `Control_flow` · [[Control_theory]] · `Cross-validation_(statistics)` · `Cryptographic_protocol` · `Cryptography` · `Cyber-physical_system` · `Cyberwarfare` · `DECnet` · `Daniel_Davis_Jr.` · `Data_communication` · [[Data_compression]] · `Data_integrity` · `Data_link_layer` · `Data_mining` · `Data_structure` · `Database` · `Datagram` · `Datagram_Congestion_Control_Protocol` · `Dawon_Kahng` · `De_facto_standard` · `Debugging` · `Decision_support_system` · [[Dependability]] · `Digital_art` · [[Digital_library]] · `Digital_marketing` · `Digital_media` · `Digital_subscriber_line` · `Digital_television` · [[Discrete_cosine_transform]] · `Discrete_mathematics` · `Distributed_artificial_intelligence` · `Distributed_computing` · `Document_management_system` · `Domain-specific_language` · `Domain_Name_System` · `Donald_Davies` · `Drums_in_communication` · `Dynamic_Host_Configuration_Protocol` · `E-commerce` · `EbXML` · `Edholm's_law` · `Educational_technology` · `Edwin_Howard_Armstrong` · `Electrical_telegraph` · `Electronic_design_automation` · `Electronic_publishing` · `Electronic_voting` · `Elisha_Gray` · `Embedded_system` · `Emile_Berliner` · `Encapsulation_(networking)` · `Encyclopædia_Britannica` · `End-to-end_principle` · `Enterprise_Distributed_Object_Computing` · `Enterprise_information_system` · `Enterprise_software` · `Erna_Schneider_Hoover` · [[Error_detection_and_correction]] · `Ethernet` · `Extended_reality` · [[Extensibility]] · `External_Data_Representation` · [[Fault_tolerance]] · `Fax` · `Fiber-optic_communication` · `FidoNet` · `File_Transfer_Protocol` · [[Finite-state_machine]] · `Form_factor_(design)` · `Formal_language` · `Formal_methods` · `Frame_Relay` · `Francis_Blake_(inventor)` · `Free-space_optical_communication` · `Frequency-division_multiplexing` · `G.hn` · `Gardiner_Greene_Hubbard` · `Generic_Framing_Procedure` · `Geographic_information_system` · `Gerard_J._Holzmann` · `Gopher_(protocol)` · [[Graphics_processing_unit]] · `Green_computing` · `Guglielmo_Marconi` · `HTTP/2` · `HTTP/3` · `Hardware_acceleration` · `Hardware_security` · `Harold_Hopkins_(physicist)` · `Health_informatics` · `Hedy_Lamarr` · `Heliograph` · `Henry_Sutton_(inventor)` · `High-Level_Data_Link_Control` · `History_of_broadcasting` · `History_of_mobile_phones` · `History_of_prepaid_mobile_phones` · `History_of_radio` · `History_of_telecommunication` · `History_of_television` · `History_of_the_Internet` · `History_of_the_telephone` · `History_of_the_transistor` · `History_of_videotelephony` · `Host_(network)` · `Human-centered_computing` · `Human–computer_interaction` · `Hydraulic_telegraph` · `I.430` · `I.431` · `IBM` · `ICMPv6` · `IEEE_1394` · `IEEE_802` · `IEEE_Spectrum` · `IPX/SPX` · `IPsec` · `IPv4` · `IPv6` · `IS-IS` · `ITU-T` · [[Image_compression]] · [[Implementation]] · [[Industrial_process_control]] · [[Information]] · `Information_Age` · `Information_retrieval` · `Information_security` · [[Information_system]] · [[Information_theory]] · `Innocenzo_Manzetti` · `Institute_of_Electrical_and_Electronics_Engineers` · `Integrated_circuit` · `Integrated_development_environment` · `Interaction_design` · `International_Network_Working_Group` · `International_Organization_for_Standardization` · `International_Telecommunication_Union` · `Internet` · `Internet2` · `Internet_Architecture_Board` · `Internet_Control_Message_Protocol` · `Internet_Engineering_Task_Force` · `Internet_Group_Management_Protocol` · `Internet_Protocol` · `Internet_privacy` · `Internet_protocol_suite` · `Internet_video` · `Internetwork_Packet_Exchange` · `Internetworking` · `Interpreter_(computing)` · `Intrusion_detection_system` · `JANET` · `JSON` · `Jagadish_Chandra_Bose` · `Janet_Abbate` · `Johann_Philipp_Reis` · `John_Bardeen` · `John_Logie_Baird` · `Jon_Postel` · `Jun-ichi_Nishizawa` · `Knowledge_representation_and_reasoning` · `LAPB` · `Layer_2_Tunneling_Protocol` · `Lee_de_Forest` · `Library_(computing)` · `Link_Access_Procedure_for_Frame_Relay` · `Link_access_procedure` · `List_of_ITU-T_V-series_recommendations` · `List_of_Internet_pioneers` · `List_of_computer_size_categories` · `List_of_network_protocols_(OSI_model)` · `List_of_telecommunications_regulatory_bodies` · `List_of_wireless_network_protocols` · `Lists_of_network_protocols` · `Local_area_network` · `Logic_in_computer_science` · `Logical_link_control` · `Lossless_compression` · `Louis_Pouzin` · `MIME` · `MOSFET` · [[Machine_learning]] · `Marine_electronics` · `Martin_Fowler_(software_engineer)` · `Mass_media` · `Mathematical_analysis` · [[Mathematical_optimization]] · [[Mathematical_software]] · `Maximum_transmission_unit` · `Mealy_machine` · `Medium_access_control` · `Middlebox` · `Middleware` · `Mobile_computing` · `Mobile_telephony` · `Model_of_computation` · `Modeling_language` · `Mohamed_M._Atalla` · `Molecular_communication` · `Moore_machine` · `Multi-task_learning` · `Multimedia_database` · `Multiplexing` · [[Multiprocessing]] · [[Multithreading_(computer_architecture)]] · `NETCONF` · `NPL_network` · `Named_pipe` · `Narinder_Singh_Kapany` · `Nasir_Ahmed_(engineer)` · `National_Physical_Laboratory_(United_Kingdom)` · `Natural_language_processing` · `NetBIOS` · `Network_File_System` · `Network_News_Transfer_Protocol` · `Network_Time_Protocol` · `Network_architecture` · `Network_congestion` · `Network_layer` · `Network_performance` · `Network_scheduler` · `Network_security` · `Network_service` · `Network_switch` · `Network_topology` · `Networking_hardware` · `Next-generation_network` · `Nikola_Tesla` · `Node_(networking)` · `Numerical_analysis` · `OSI_model` · `Oligopoly` · `Oliver_Heaviside` · `Online_video_platform` · `Open_source` · `Operating_system` · [[Operations_research]] · `Optical_communication` · `Optical_fiber` · `Optical_telegraph` · `Orbital_angular_momentum_multiplexing` · `Oticon` · `Outline_of_computer_science` · `Outline_of_telecommunication` · `PARC_Universal_Packet` · `Packet_Layer_Protocol` · `Packet_switching` · `Pager` · `Parallel_Line_Internet_Protocol` · `Parallel_computing` · `Parsing` · `Passive_optical_network` · `Paul_Baran` · `Peripheral` · `Philo_Farnsworth` · `Philosophy_of_artificial_intelligence` · `Photograph_manipulation` · `Photophone` · `Phryctoria` · `Physical_layer` · `Plain_text` · `Plesiochronous_digital_hierarchy` · `Point-to-Point_Protocol` · `Point-to-Point_Tunneling_Protocol` · `Polarization-division_multiplexing` · `Presentation_layer` · `Pretty_Good_Privacy` · `Printed_circuit_board` · [[Probability]] · `Processor_(computing)` · `Programming_language` · `Programming_language_theory` · `Programming_paradigm` · `Programming_team` · `Programming_tool` · `Proprietary_protocol` · `Protocol_Builder` · `Protocol_Wars` · `Protocol_ossification` · `Protocol_stack` · `Public_switched_telephone_network` · `QUIC` · [[Quantum_computing]] · `RS-232` · `RS-449` · `Radia_Perlman` · `Radio` · `Radio_network` · `Radio_wave` · `Radiotelephone` · `Randomized_algorithm` · `Real-time_Transport_Protocol` · [[Real-time_computing]] · `Reginald_Fessenden` · [[Reinforcement_learning]] · `Rendering_(computer_graphics)` · `Request_for_Comments` · `Requirements_analysis` · `Robert_Hooke` · `Robert_Metcalfe` · `Roberto_Landell_de_Moura` · `Roger_Scantlebury` · `Rémi_Després` · `SATNET` · `SOCKS` · `Samuel_Morse` · `Secure_Shell` · `Security_hacker` · `Security_service_(telecommunication)` · `Semaphore` · `Semiconductor` · [[Semiconductor_device]] · `Serial_Line_Internet_Protocol` · `Session_Announcement_Protocol` · `Session_Initiation_Protocol` · `Session_layer` · `Shared_medium` · `Shared_memory` · `Short_Message_Peer-to-Peer` · `Simple_Mail_Transfer_Protocol` · `Simple_Network_Management_Protocol` · `Simple_Sensor_Interface_protocol` · `Smartphone` · `Smoke_signal` · `Social_computing` · `Social_media` · `Social_software` · `Software` · `Software_configuration_management` · `Software_construction` · `Software_deployment` · `Software_design` · `Software_design_pattern` · `Software_development` · `Software_development_process` · [[Software_engineering]] · `Software_framework` · `Software_maintenance` · [[Software_quality]] · `Software_repository` · `Solid_modeling` · `Space-division_multiple_access` · `Standards_organization` · `Starkey_Hearing_Technologies` · `State_(computer_science)` · `Statistics` · `Steve_Crocker` · `Stochastic_computing` · `Store_and_forward` · `Stream_Control_Transmission_Protocol` · `Streaming_media` · `Streaming_television` · `Submarine_communications_cable` · `Supervised_learning` · [[Synchronization]] · `Synchronous_Data_Link_Control` · `Synchronous_optical_networking` · `Syntax` · `System_on_a_chip` · `Systems_Network_Architecture` · [[Systems_engineering]] · `TANet` · `Technical_standard` · `Technological_convergence` · `Telautograph` · `Telecommunication_circuit` · [[Telecommunications]] · `Telecommunications_equipment` · `Telecommunications_link` · `Telecommunications_network` · `Telegraphy` · `Telephone` · `Telephone_exchange` · `Teleprinter` · `Telex` · `Telnet` · `Terminal_(telecommunication)` · `The_Telephone_Cases` · `Theoretical_computer_science` · `Theory_of_computation` · `Thomas_A._Watson` · `Thomas_Edison` · `Tim_Berners-Lee` · `Time-division_multiplexing` · `Timeout_(computing)` · `Tivadar_Puskás` · `Toasternet` · `Tony_Hoare` · `Transmission_Control_Protocol` · `Transmission_line` · `Transmission_medium` · `Transport_Layer_Security` · `Transport_layer` · `Tunneling_protocol` · `USB` · `UTF-8` · `UUCP` · `Ubiquitous_computing` · `Unsupervised_learning` · `Usenet` · `User_Datagram_Protocol` · [[Very-large-scale_integration]] · `Video_coding_format` · `Video_game` · `Vint_Cerf` · `Virtual_circuit` · `Virtual_machine` · [[Virtual_reality]] · `Visualization_(graphics)` · `Vladimir_K._Zworykin` · [[Wayback_Machine]] · `Whistled_language` · `Wide_area_network` · `Wire_data` · `Wireless` · `Wireless_network` · `Wireless_sensor_network` · `Word_processor` · `World_Wide_Web` · `World_Wide_Web_Consortium` · `X.21` · `X.25` · `XML` · `Xerox_Network_Systems` ## From the Real GENERATIVE library ![Communication protocol](https://upload.wikimedia.org/wikipedia/commons/thumb/a/a6/Internet_layering.svg/220px-Internet_layering.svg.png) *Communication protocol — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Telecommunications room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:Internet_layering.svg).* > A communication protocol is a system of rules that allows two or more entities of a communications system to transmit information via any variation of a physical quantity. The protocol defines the rules, syntax, semantics, and synchronization of communication and possible error recovery methods. ([Wikipedia](https://en.wikipedia.org/wiki/Communication_protocol)) <!-- REAL-GENERATIVE-MEDIA:END --> <!-- LOCAL-MEDIA-PASS:START --> ## From the vault media library !Communication protocol thumb.png *Communication Protocol — from the vault's own media holdings, placed 2026-07-09. MTN / Wikitube.io original · CC BY-SA 4.0.* <!-- LOCAL-MEDIA-PASS:END --> > **Room:** Audio · **Status:** ✅ shipped ## Overview A communication protocol is a [[System|system]] of rules that allows two or more entities of a [[Communications_system|communications system]] to transmit [[Information|information]] via any variation of a physical quantity. The protocol defines the rules, syntax, semantics, and [[Synchronization|synchronization]] of communication and possible error recovery methods. Protocols may be implemented by hardware, software, or a combination of both.1 _(Overview is shorter than 200 words; the pipeline should expand it from textbook context before publishing.)_ ## See also - Room hub: Audio - p5.js Editor conventions: P5 JS EDITOR - Wiki root: MAIN --- *Scaffolded by `generative-microsim` from row 13 of the Audio sheet on 2026-06-04T01:15:43Z.* <!-- REAL-GENERATIVE-MEDIA:START --> <!-- CRAFT-LINK:START g12 --> *Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].* <!-- CRAFT-LINK:END --> ## Wikipedia : Wikitube **Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Communication_protocol) : [Wikitube](https://en.wikitube.io/wiki/Communication_protocol) ## Previous hub tags Tree parents: [[Graph_theory]] · [[Information_theory]] · [[Systems_engineering]]. Legacy hubs: `GENERATIVE`. --- *Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*