User Datagram Protocol (UDP) is a transport layer protocol designed for speed and simplicity. Unlike TCP, UDP operates in a stateless, connectionless model. This means that when you send data using UDP, there is no need to establish or maintain a connection between the sender and receiver. Each message, called a datagram, is sent independently, and the protocol does not guarantee delivery, order, or error correction. This minimal-overhead approach allows UDP to transmit data quickly, making it ideal for applications where speed is more critical than reliability, such as live audio or video streaming. However, the absence of state and connection management also means that you, as the application developer, are responsible for handling lost or out-of-order packets if your use case requires reliability.

To illustrate how UDP works, consider the following pseudo code for sending and receiving datagrams. Notice that there is no connection setup phase; you simply create a socket, specify the destination, and send the data.

Sending a UDP datagram:

create_udp_socket()
set_destination_address(ip, port)
send_datagram(socket, data, destination)
close_socket(socket)

Receiving a UDP datagram:

create_udp_socket()
bind_socket_to_port(socket, port)
data, sender = receive_datagram(socket)
process_received_data(data)
close_socket(socket)

In this model, the sender does not know whether the receiver is ready or even exists, and the receiver simply waits for incoming datagrams on a specific port. This statelessness is a defining feature of UDP.

Diving deeper, the UDP header is extremely compact, consisting of only four fields: Source Port, Destination Port, Length, and Checksum. The Source and Destination Port fields identify the sending and receiving application processes. The Length field specifies the total length of the UDP header and data. The Checksum provides basic error detection by allowing the receiver to verify the integrity of the data.

The checksum is calculated by taking the one's complement of the one's complement sum of the pseudo header, UDP header, and data. If the computed checksum does not match the value in the packet, the packet is discarded. However, UDP does not retransmit lost packets or correct errors—its error detection is limited to this checksum mechanism.

UDP is commonly used for applications that require low latency or can tolerate some data loss. Typical use cases include Domain Name System (DNS) queries, where quick responses are essential and occasional loss can be retried by the application, and streaming media, where real-time delivery is more important than perfect accuracy.

Here is pseudo code to illustrate how a UDP checksum is computed and how a packet is handled upon receipt:

UDP checksum computation:

function compute_udp_checksum(pseudo_header, udp_header, data):
    sum = 0
    sum += sum_of_16bit_words(pseudo_header)
    sum += sum_of_16bit_words(udp_header)
    sum += sum_of_16bit_words(data)
    checksum = one's_complement(sum)
    return checksum

UDP packet handling:

on_receive_udp_packet(packet):
    computed_checksum = compute_udp_checksum(packet.pseudo_header, packet.header, packet.data)
    if computed_checksum == 0:
        process_data(packet.data)
    else:
        discard_packet()

This process ensures that corrupted packets are detected and discarded, but does not provide correction or retransmission.