Data arrives from the physical layer as a raw, undifferentiated stream of bits. It's just a long sequence of ones and zeros. The Data Link layer's first job is to chop this stream into manageable chunks called frames. Framing provides structure, marking the beginning and end of each packet so the receiving device knows what it's looking at.

One early method was the character count. The frame's header would simply state how many characters were in the frame. For example, a header value of 5 would tell the receiver to read the next five bytes as a single frame. This works, but it's brittle. If a cosmic ray flips a bit in the count field, the receiver loses its place, and every subsequent frame is misinterpreted until the connection resets. It’s a chain reaction of errors.

A more robust approach is bit stuffing a technique that uses a special bit pattern, or "flag," to mark the start and end of a frame (e.g., 01111110). But what if that same pattern appears in the actual data? The receiver would mistakenly think the frame has ended. To prevent this, the sending device "stuffs" an extra bit into the data stream whenever it detects a pattern that looks too much like the flag. For example, if the flag has six consecutive 1s, the sender inserts a 0 after any five consecutive 1s in the data. The receiver knows this rule and automatically removes the stuffed 0, restoring the original data perfectly.

Once data is framed, we need to ensure it arrived intact. Physical mediums are noisy. Interference from a microwave oven, a solar flare, or just thermal noise can flip bits, corrupting the data. The Data Link layer doesn't just hope for the best; it actively checks for errors.

A basic method is a checksum. The sender performs a simple calculation on the data, like adding up all the bytes, and appends the result to the frame. The receiver performs the exact same calculation. If the results match, the data is likely correct. If not, an error occurred. While simple, basic checksums can miss certain types of errors, like two transposed bytes.

For more robust detection, networks like Ethernet rely on a Cyclic Redundancy Check (CRC). This method treats the bit string of a frame as a representation of a polynomial. The sender divides this polynomial by a fixed, predefined generator polynomial. The remainder of this division becomes the CRC value, which is attached to the frame. The receiver performs the same division. If the remainder is zero, the frame is accepted as valid.

Detecting an error is one thing; correcting it is another. The simplest strategy is retransmission. If the receiver detects an error using a CRC, it discards the bad frame and sends a request back to the sender to send it again. This works well but introduces latency, especially over long-distance or high-error-rate links.

The alternative is Forward Error Correction (FEC). With FEC, the sender includes extra redundant data within the frame itself. This extra data is carefully constructed so that even if some of the original bits are corrupted, the receiver can use the redundant information to reconstruct the correct data without needing a retransmission. This adds overhead to every packet but is invaluable in situations where retransmission is impractical, like streaming video or deep-space communication.

A classic example of FEC is the Hamming code, which can detect up to two-bit errors or correct one-bit errors. It works by strategically placing several parity bits within the data. Each parity bit checks a different, overlapping subset of the data bits. When the receiver gets the data, it recalculates the parity bits. If any are incorrect, the specific pattern of parity errors (called the syndrome) directly indicates which bit flipped, allowing the receiver to correct it on the spot.

By organizing bits into frames and embedding mechanisms for error detection and correction, the Data Link layer transforms an unreliable physical connection into a dependable link for its neighbors, ready for the Network layer to take over.