Problems with Time-Based Code & How Fake Clocks Solve Them

Mohammad Zeya Ahmad — Wed, 16 Apr 2025 01:49:27 +0000

⚠️ Problems with Time-Based Code in Tests

When writing Go programs, we often rely on time-related functions like:

time.After
time.NewTicker
time.NewTimer
time.Sleep

These are useful for implementing timeouts, periodic tasks, and scheduled operations. However, they introduce several problems in tests:

1️⃣ Tests Become Slow

If a function waits 10 seconds before timing out, your test also takes 10 seconds.
This slows down CI/CD pipelines and developer productivity.

2️⃣ Flaky Tests (Intermittent Failures)

Real-world execution times fluctuate due to CPU load, network latency, and system clock drift.
Example: A timeout-based test might pass on a fast machine but fail on a slow one.

3️⃣ No Control Over Time

You can’t fast-forward time or pause execution.
Makes it hard to simulate timeouts, retries, and delays.

4️⃣ Hard to Test Race Conditions

Go routines using real time can interleave unpredictably, leading to non-deterministic tests.

✅ Solution: Using Fake Clocks in Go

To solve these problems, we use a fake clock instead of the real time package. Fake clocks allow us to:

✅ Fast-forward time instead of waiting in real-time.

✅ Ensure predictable timing behavior in tests.

✅ Make tests run instantly, improving speed.

✅ Simulate timeouts, delays, and retries deterministically.

🛠 Example 1: Testing a Timeout Without Waiting

🔹 Problem:

Let's say we have a function that waits for an event but times out after 5 seconds if nothing happens.

package main

import (
    "fmt"
    "time"
)

func waitForEvent(timeout time.Duration) error {
    select {
    case <-time.After(timeout):
        return fmt.Errorf("timeout occurred")
    }
}

🔹 Issues in Tests:

Running this test would take 5 seconds!
If you had 10 tests, your test suite would take 50+ seconds to complete.

✅ Solution: Fake Clock

📌 Install the package:

go get github.com/benbjohnson/clock

📌 Rewriting the function using a Fake Clock:

package main

import (
    "fmt"
    "time"

    "github.com/benbjohnson/clock"
)

func waitForEventWithClock(clk clock.Clock, timeout time.Duration) error {
    select {
    case <-clk.After(timeout):
        return fmt.Errorf("timeout occurred")
    }
}

📌 Test using Fake Clock:

package main

import (
    "testing"
    "time"

    "github.com/benbjohnson/clock"
    "github.com/stretchr/testify/assert"
)

func TestWaitForEventTimeout(t *testing.T) {
    clk := clock.NewMock() // Create a mock clock

    // Run the function in a goroutine
    done := make(chan error)
    go func() {
        done <- waitForEventWithClock(clk, 5*time.Second)
    }()

    // Fast-forward time by 5 seconds
    clk.Add(5 * time.Second)

    // Verify the result
    assert.Equal(t, fmt.Errorf("timeout occurred"), <-done)
}

✅ Test runs instantly! No need to wait for 5 seconds.

🛠 Example 2: Testing a Ticker Without Waiting

🔹 Problem:

A ticker prints "tick" every 2 seconds:

package main

import (
    "fmt"
    "time"
)

func startTicker() {
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    for t := range ticker.C {
        fmt.Println("Tick at:", t)
    }
}

🔹 Issues in Tests:

Takes 2 seconds per tick → very slow tests.
Hard to control timing.

✅ Solution: Fake Clock

📌 Rewriting the function using Fake Clock:

package main

import (
    "fmt"
    "time"

    "github.com/benbjohnson/clock"
)

func startTickerWithClock(clk clock.Clock) {
    ticker := clk.Ticker(2 * time.Second)
    defer ticker.Stop()

    for t := range ticker.C {
        fmt.Println("Tick at:", t)
    }
}

📌 Test using Fake Clock:

package main

import (
    "testing"
    "time"

    "github.com/benbjohnson/clock"
    "github.com/stretchr/testify/assert"
)

func TestTicker(t *testing.T) {
    clk := clock.NewMock() // Create a mock clock
    ticker := clk.Ticker(2 * time.Second)
    defer ticker.Stop()

    // Advance time by 2 seconds
    clk.Add(2 * time.Second)

    // Check if the ticker ticked
    select {
    case <-ticker.C:
        // Success: Ticker worked as expected
    default:
        t.Fatal("Ticker did not tick")
    }
}

✅ Test runs instantly! We fast-forward time instead of waiting.

⏳ Summary

Problem	Solution
Slow tests (timeouts/tickers)	Use fake clocks to fast-forward time
Flaky tests (random failures)	Control time manually for consistent behavior
Uncontrollable race conditions	Deterministic execution using Fake Clocks
Hard to test retries	Simulate retries instantly

Fake clocks make testing time-dependent code easy, fast, and reliable! 🚀

Here are some great resources to learn more about testing time-dependent code in Go using fake clocks:

📖 Articles & Blog Posts

Using Fake Clocks in Go – A deep dive into the concept of fake clocks with Go code examples.
Testing Time in Go – Explains different approaches to testing time-based code.
Effective Testing for Go Applications – Discusses mock implementations in Go, including fake clocks.

📚 Official Documentation & Libraries

Ben Johnson's clock package – The most widely used Go library for fake clocks.
Go time package documentation – Understanding the standard time package is essential before using fake clocks.

🎥 Video Tutorials

Go Testing Techniques - GopherCon – Covers various testing strategies, including time-based testing.
Mocking Time in Go - Tutorial – Hands-on implementation of fake clocks in Go.

⚡ Latency Numbers Every Programmer Should Know

Mohammad Zeya Ahmad — Mon, 24 Mar 2025 21:56:39 +0000

⚡ Latency Numbers Every Programmer Should Know

Understanding the relative speed of different operations in computing is crucial for writing efficient code. Below is a list of key latency numbers, from CPU cache accesses to network round trips.

🏎️ CPU & Memory Operations

Operation	Time	Emoji Representation
🏷️ L1 cache reference	0.5 ns	🔥 Ultra-fast
🔀 Branch mispredict	5 ns	🔄 Slight penalty
🏷️ L2 cache reference	7 ns	🚀 Fast
🔐 Mutex lock/unlock	100 ns	🔒 Synchronization cost
🎯 L3 cache reference	30 ns	🎯 Moderate speed
🧠 Main memory reference	100 ns	📦 Memory access

📡 Data Compression & Transfer

Operation	Time	Emoji Representation
📦 Compress 1K bytes with Zippy	10 µs	🗜️ Compression cost
🌐 Send 2K bytes over 1 Gbps network	20 µs	📡 Network transfer
📚 Read 1 MB sequentially from memory	250 µs	📖 RAM read

🏢 Datacenter & Disk Operations

Operation	Time	Emoji Representation
🏢 Round trip within the same datacenter	500 µs	🔄 Local network
💽 Disk seek (random access on HDD)	10 ms	🛑 Expensive
🌍 Read 1 MB sequentially from the network	10 ms	🌐 Internet speed
💾 Read 1 MB sequentially from SSD	1 ms	⚡ Fast storage
📀 Read 1 MB sequentially from HDD	30 ms	🐢 Slow disk access

🌎 Network & Intercontinental Transfers

Operation	Time	Emoji Representation
🚀 Packet transmission across the US	50 ms	✈️ Coast-to-coast
🌍 Packet round-trip US → Europe	100 ms	🌐 Intercontinental
🚀 Packet round-trip CA → Netherlands → CA	150 ms	🛰️ Global transfer
🚀 Packet one-way Earth → Mars (at closest distance)	4-24 min	🛸 Interplanetary delay

🔥 Key Takeaways

Nanoseconds (ns) ⚡: CPU operations, cache, and memory references.
Microseconds (µs) ⏳: Network and data compression operations.
Milliseconds (ms) 🐢: Disk access, network round trips.
Minutes 🚀: Deep-space communication delays.

🚀 If you found this helpful, follow me for more programming insights!

DEV Community: Mohammad Zeya Ahmad

Problems with Time-Based Code & How Fake Clocks Solve Them

⚠️ Problems with Time-Based Code in Tests

1️⃣ Tests Become Slow

2️⃣ Flaky Tests (Intermittent Failures)

3️⃣ No Control Over Time

4️⃣ Hard to Test Race Conditions

✅ Solution: Using Fake Clocks in Go

🛠 Example 1: Testing a Timeout Without Waiting

🔹 Problem:

🔹 Issues in Tests:

✅ Solution: Fake Clock

🛠 Example 2: Testing a Ticker Without Waiting

🔹 Problem:

🔹 Issues in Tests:

✅ Solution: Fake Clock

⏳ Summary

📖 Articles & Blog Posts

📚 Official Documentation & Libraries

🎥 Video Tutorials

⚡ Latency Numbers Every Programmer Should Know

⚡ Latency Numbers Every Programmer Should Know

🏎️ CPU & Memory Operations

📡 Data Compression & Transfer

🏢 Datacenter & Disk Operations

🌎 Network & Intercontinental Transfers

🔥 Key Takeaways