📬 धडा 05 — TCP विरुद्ध UDP: नोंदणीकृत टपाल विरुद्ध लाउडस्पीकर

📍 तुम्ही इथे आहात: 12 पैकी धडा 05 · पुढे: lesson-06-dns

📦 या ब्रँचमध्ये काय आहे

धडे 01–05. transport चे दोन करार, खऱ्या sockets वर पाहिलेले.

net/demo.py — tcp: एक handshake, तीन तुकडे, एक पावती; udp: दहा आरोळ्या, काही हरवलेल्या

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

नोंदणीकृत टपाल (TCP): पहिल्या पत्राआधी दोन्ही कार्यालये बोलायला तयार होतात — "तयार?" "तयार!" "चला" — आणि त्यानंतर प्रत्येक पत्राला क्रमांक असतो, त्यावर सही घेतली जाते, हरवले तर पुन्हा पाठवले जाते, आणि क्रमाने दिले जाते. सुरुवात हळू, पण काहीही हरवत नाही.

लाउडस्पीकर (UDP): तुम्ही घोषणा एकदाच ओरडून सांगता. करार नाही, क्रमांक नाहीत, पावती नाही. corridor मधल्या काही लोकांना ती ऐकू येत नाही. झटपट, स्वस्त, आणि उशिरापेक्षा पुन्हा सांगणे बरे असते तेव्हा अगदी योग्य — video frame, game मधली position, directory ला विचारलेला प्रश्न.

🗺️ आकृती

sequenceDiagram
  participant C as client
  participant S as server
  Note over C,S: TCP — registered post
  C->>S: SYN
  S->>C: SYN-ACK
  C->>S: ACK  (a pipe exists)
  C->>S: bytes #1..31
  S->>C: ACK 31 · "receipt"
  Note over C,S: UDP — the loudspeaker
  C-->>S: datagram (maybe)
  C-->>S: datagram (lost)

❓ काय

TCP: connection-oriented, भरवशाचा, क्रमाने, flow- आणि congestion-controlled. एक stream: संदेशांना सीमा नसतात — घेणाऱ्याला फक्त bytes दिसतात, म्हणून protocols स्वतःच्या सीमा जोडतात (newline, length prefix, HTTP ची रिकामी ओळ).
UDP: connection शिवाय datagrams; हरवू शकतात, दोनदा येऊ शकतात, क्रम बदलू शकतो; छोटा header; बाकीचे application सांभाळते.
Ports दोघांचेही असतात. 443/tcp आणि 443/udp या वेगळ्या खोल्या आहेत.

🤔 का

चुकीचा निवडला तर एकतर अचूकता जाते किंवा latency वाढते. Web, mail, databases: TCP. DNS, video, voice, games, HTTP/3: UDP, स्वतःच्या हुशारीसह.

🔧 कसे (या repo मध्ये)

tcp() एक listening socket bind करतो, एका thread मध्ये accept करतो, आणि client थांबे घेत तीन तुकडे पाठवतो — stream ला कडा नसल्यामुळे कारकून newline येईपर्यंत वाचतो. udp() मुद्दाम 30% पाठवणी टाकून देतो आणि काय पोहोचले ते दाखवतो.

🧪 करून पाहा

python3 net/demo.py tcp udp
python3 - <<'EOF'
import socket; s=socket.socket(); s.settimeout(1)
print(s.connect_ex(("127.0.0.1", 9)))     # nothing listens on 9: refused fast (111/61) — a closed room
EOF

✅ तपासा — तुम्हाला काय दिसायला हवे

TCP: "sent 3 pieces; the clerk answered: receipt: 31 bytes". UDP: "10 …, 6 heard" (seed ठरलेला आहे, म्हणून बरोबर सहा). बंद खोली लगेच शून्य नसलेला code परत करते — धडा 10 मधल्या firewall ने अडवलेल्या port च्या शांततेशी तुलना करा.

🏁 तुम्ही आत्ताच काय सिद्ध केले

TCP च्या हमी खऱ्या आहेत आणि दिसतात; UDP मधले हरवणे खरे आहे आणि दिसते; आणि TCP stream वर संदेशांच्या सीमा तुम्हालाच जोडाव्या लागतात.

⚠️ नेहमीच्या चुका

एक send = एक recv असे गृहीत धरणे. streams तुटतात आणि जुळतात; तुमच्या संदेशांना frame करा.
UDP वापरणे आणि "कधीकधी" म्हणजे "production मध्ये, रोज" हे विसरणे.
तुमच्याच protocol मधल्या गहाळ newline मुळे अडकलेल्या गोष्टीसाठी network ला दोष देणे.

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: head-of-line blocking, connection pools, keep-alive, आणि 3-way handshake चा round trip — ही सगळी TCP ची तथ्ये p99 latency म्हणून दिसतात. नेमके ते सोडवण्यासाठीच HTTP/3 UDP वर गेला.

⏭️ पुढे

धडा 06 — DNS: नावाचे पत्त्यात रूपांतर करणारी directory, आणि ती प्रत्येक outage ची सुरुवात का असते.

📬 Lesson 05 — TCP vs UDP: registered post vs the loudspeaker

📍 You are here: Lesson 05 of 12 · Next: lesson-06-dns

📦 What's in this branch

Lessons 01–05. The two transport contracts, seen on real sockets.

net/demo.py — tcp: a handshake, three pieces, one receipt; udp: ten shouts, some lost

🧒 Explain like I'm 5

Registered post (TCP): before the first letter, both offices agree to talk — "ready?" "ready!" "go" — and after that every letter is numbered, signed for, re-sent if it goes missing, and handed over in order. Slow to start, but nothing is lost.

The loudspeaker (UDP): you shout the announcement once. No agreement, no numbers, no receipt. Some people in the corridor miss it. Instant, cheap, and exactly right when a repeat is better than a delay — a video frame, a game position, a directory question.

🗺️ Diagram

sequenceDiagram
  participant C as client
  participant S as server
  Note over C,S: TCP — registered post
  C->>S: SYN
  S->>C: SYN-ACK
  C->>S: ACK  (a pipe exists)
  C->>S: bytes #1..31
  S->>C: ACK 31 · "receipt"
  Note over C,S: UDP — the loudspeaker
  C-->>S: datagram (maybe)
  C-->>S: datagram (lost)

❓ What

TCP: connection-oriented, reliable, ordered, flow- and congestion-controlled. A stream: no message boundaries — the receiver sees bytes, so protocols add their own (newline, length prefix, HTTP's blank line).
UDP: connectionless datagrams; may be lost, duplicated, reordered; tiny header; the application handles the rest.
Ports belong to both. 443/tcp and 443/udp are different rooms.

🤔 Why

Choosing the wrong one costs either correctness or latency. Web, mail, databases: TCP. DNS, video, voice, games, HTTP/3: UDP with their own smarts.

🔧 How (in this repo)

tcp() binds a listening socket, accepts in a thread, and the client sends three pieces with pauses — the clerk reads until a newline because the stream has no edges. udp() drops 30% of sends on purpose and shows what arrived.

🧪 Try it

python3 net/demo.py tcp udp
python3 - <<'EOF'
import socket; s=socket.socket(); s.settimeout(1)
print(s.connect_ex(("127.0.0.1", 9)))     # nothing listens on 9: refused fast (111/61) — a closed room
EOF

✅ Verify — what you should see

TCP: "sent 3 pieces; the clerk answered: receipt: 31 bytes". UDP: "10 …, 6 heard" (the seed is fixed, so exactly six). The closed room returns a non-zero code immediately — compare with a firewalled port's silence in lesson 10.

🏁 What you just proved

TCP's guarantees are real and visible; UDP's losses are real and visible; and message boundaries are yours to add on a TCP stream.

⚠️ Common mistakes

Assuming one send = one recv. Streams split and merge; frame your messages.
Using UDP and forgetting that "sometimes" means "in production, daily".
Blaming the network for a hang that is a missing newline in your own protocol.

🏭 Why this matters in production: head-of-line blocking, connection pools, keep-alive, and the 3-way handshake's round trip are all TCP facts that show up as p99 latency. HTTP/3 moved to UDP precisely to fix them.

⏭️ Next

Lesson 06 — DNS: the directory that turns a name into an address, and why it opens every outage.

← Previouslayers Next →dns

This page is the lesson's README from the lesson-05-tcp-udp branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.