Networking and Time

🌐 Rust Networking & Time: Your Computer’s Phone and Clock

Imagine your computer is like a little house. Sometimes, your house needs to call another house (that’s networking!). And sometimes, your house needs to know what time it is or how long something took (that’s time!). Rust gives you special tools in its Standard Library to do both!

🏠 The Story: Two Houses Want to Talk

Meet House A and House B. They live on the Internet Street. They want to send messages to each other. But how?

Rust gives them two ways to talk:

1. TCP - Like a phone call (you connect first, then talk)
2. UDP - Like throwing a letter over the fence (just toss it and hope!)

And to track how long their conversations take, they use:

1. Duration - “The call lasted 5 minutes”
2. Instant - “I started the call at this exact moment”

📞 TCP Networking: The Reliable Phone Call

What is TCP?

TCP stands for Transmission Control Protocol. Think of it like making a phone call:

1. You dial the number (connect)
2. The other person picks up (accept)
3. You talk back and forth (send/receive)
4. You say goodbye and hang up (close)

The magic of TCP: Every message arrives in order, and nothing gets lost!

TCP in Real Life

• When you visit a website (like watching YouTube)
• When you send an email
• When you play online games that need everything to be exact

How TCP Works in Rust

// SERVER (House B - waiting for calls)
use std::net::TcpListener;
use std::io::Read;

fn main() {
    // 1. Get a phone number (bind to address)
    let listener = TcpListener::bind("127.0.0.1:8080")
        .expect("Could not bind!");

    println!("Waiting for calls...");

    // 2. Wait for someone to call
    for stream in listener.incoming() {
        let mut stream = stream.unwrap();
        let mut buffer = [0; 512];

        // 3. Read the message
        stream.read(&mut buffer).unwrap();
        println!("Got message!");
    }
}

// CLIENT (House A - making the call)
use std::net::TcpStream;
use std::io::Write;

fn main() {
    // 1. Dial the number (connect)
    let mut stream = TcpStream::connect("127.0.0.1:8080")
        .expect("Could not connect!");

    // 2. Say something
    stream.write(b"Hello, House B!")
        .expect("Failed to send!");

    println!("Message sent!");
}

Key TCP Types

TCP is Like…

graph TD
    A["House A wants to talk"] --> B[Dials House B's number]
    B --> C["House B picks up"]
    C --> D["They chat back and forth"]
    D --> E["They say goodbye"]
    E --> F["Call ends cleanly"]

Remember: TCP = Phone Call = Reliable but needs setup!

📮 UDP Networking: The Quick Letter Toss

What is UDP?

UDP stands for User Datagram Protocol. Think of it like throwing a letter over the fence:

1. You write a letter
2. You throw it toward your neighbor’s yard
3. Maybe they catch it, maybe they don’t!
4. No need to wait for a reply

UDP is fast but unreliable! Things might get lost, but that’s okay for some things.

UDP in Real Life

• Video calls (if you lose one tiny piece, just keep going!)
• Online games (old position data doesn’t matter)
• Live streaming

How UDP Works in Rust

// RECEIVER (House B - watching the yard)
use std::net::UdpSocket;

fn main() {
    // 1. Stand in the yard, ready to catch
    let socket = UdpSocket::bind("127.0.0.1:8080")
        .expect("Could not bind!");

    let mut buffer = [0; 512];

    // 2. Catch whatever flies over
    let (size, sender) = socket.recv_from(&mut buffer)
        .expect("Failed to receive!");

    println!("Got {} bytes from {}", size, sender);
}

// SENDER (House A - throwing letters)
use std::net::UdpSocket;

fn main() {
    // 1. Get ready to throw
    let socket = UdpSocket::bind("127.0.0.1:0")
        .expect("Could not bind!");

    // 2. Throw the letter to House B
    socket.send_to(b"Hello over the fence!",
                   "127.0.0.1:8080")
        .expect("Failed to send!");

    println!("Letter thrown!");
}

TCP vs UDP: Quick Comparison

UDP is Like…

graph TD
    A["House A has a message"] --> B["Throws letter over fence"]
    B --> C{Did House B catch it?}
    C -->|Maybe yes| D["Great!"]
    C -->|Maybe no| E["Oh well, keep going!"]

Remember: UDP = Letter Toss = Fast but might miss!

⏱️ Duration Type: “How Long Did That Take?”

What is Duration?

Duration is like a stopwatch reading. It tells you how much time passed.

• “The download took 3 seconds”
• “Wait for 500 milliseconds”
• “The game ran for 2 hours”

Creating Durations

use std::time::Duration;

fn main() {
    // Different ways to create durations
    let five_seconds = Duration::from_secs(5);
    let half_second = Duration::from_millis(500);
    let tiny_moment = Duration::from_micros(100);
    let super_tiny = Duration::from_nanos(1000);

    // Mix seconds and nanoseconds
    let custom = Duration::new(2, 500_000_000);
    // That's 2.5 seconds!

    println!("Five seconds: {:?}", five_seconds);
}

What Can You Do With Duration?

use std::time::Duration;

fn main() {
    let a = Duration::from_secs(10);
    let b = Duration::from_secs(3);

    // Add durations
    let total = a + b; // 13 seconds

    // Subtract durations
    let diff = a - b; // 7 seconds

    // Get the parts
    println!("Seconds: {}", a.as_secs());
    println!("Milliseconds: {}", a.as_millis());

    // Check if zero
    let zero = Duration::ZERO;
    println!("Is zero? {}", zero.is_zero());
}

Duration is Like…

Think of Duration like a timer display:

┌─────────────────┐
│   00:00:05      │  ← 5 seconds
│   Duration      │
└─────────────────┘

It doesn’t know WHEN something happened—just HOW LONG!

⏰ Instant Type: “What Time Is It RIGHT NOW?”

What is Instant?

Instant is like taking a photo of your clock. It captures the exact moment in time.

The cool part? You can take two photos and see how much time passed between them!

Using Instant

use std::time::Instant;

fn main() {
    // Take a photo of the clock NOW
    let start = Instant::now();

    // Do something that takes time...
    do_some_work();

    // How long since we took that photo?
    let elapsed = start.elapsed();

    println!("That took {:?}", elapsed);
}

fn do_some_work() {
    // Pretend we're working hard!
    for _ in 0..1_000_000 {
        // busy busy busy
    }
}

Measuring Time Like a Pro

use std::time::Instant;

fn main() {
    let start = Instant::now();

    // Task 1
    task_one();
    let after_one = Instant::now();

    // Task 2
    task_two();
    let after_two = Instant::now();

    // Compare times
    let task1_time = after_one - start;
    let task2_time = after_two - after_one;
    let total_time = start.elapsed();

    println!("Task 1: {:?}", task1_time);
    println!("Task 2: {:?}", task2_time);
    println!("Total: {:?}", total_time);
}

Instant vs Duration

graph TD
    A["Instant: A point in time"] --> B["Like a timestamp"]
    C["Duration: Amount of time"] --> D["Like a stopwatch"]
    B --> E["Instant - Instant = Duration"]
    D --> F["Instant + Duration = Instant"]

Key Insight:

• Instant = WHERE you are on the timeline
• Duration = HOW FAR you traveled

🎮 Putting It All Together: A Ping Timer!

Let’s combine networking AND time:

use std::net::UdpSocket;
use std::time::Instant;

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:0")
        .unwrap();

    // Start the timer
    let start = Instant::now();

    // Send a ping
    socket.send_to(b"PING", "8.8.8.8:53")
        .unwrap();

    // Wait for response
    let mut buf = [0; 512];
    socket.recv_from(&mut buf).unwrap();

    // Stop the timer
    let ping_time = start.elapsed();

    println!("Ping took: {:?}", ping_time);
}

🧠 Quick Memory Tricks

🌟 Key Takeaways

1. TCP is reliable - Use when you need EVERY byte to arrive in order
2. UDP is fast - Use when speed matters more than perfection
3. Duration measures time spans - “5 seconds”, “100 milliseconds”
4. Instant captures moments - Like pressing the lap button on a stopwatch

🎯 When to Use What?

graph TD
    A{What do you need?} --> B{Every message must arrive?}
    B -->|Yes| C["Use TCP 📞"]
    B -->|No, speed first| D["Use UDP 📮"]

    A --> E{Time measurement?}
    E -->|How long something took| F["Use Duration ⏱️"]
    E -->|Exact moment in time| G["Use Instant ⏰"]

Congratulations! 🎉 You now understand how Rust talks to other computers (TCP & UDP) and keeps track of time (Duration & Instant). Your computer’s phone and clock are ready to use!