Subject: Urgent: Heating Repair Needed at [Your Address/Unit Number]

Dear [Landlord’s Name],

I hope you are doing well. I am writing to follow up on the heating issue in my unit at [address], which has now been without adequate heat for three weeks.

I understand that scheduling repairs can sometimes take time, but a three-week wait during cold weather has become a serious health and habitability concern. I would greatly appreciate your arranging for a certified technician to complete the repair within the next 48 hours.

I am happy to coordinate access to the unit and can be available at the following times: [list a few windows, e.g., Tuesday/Thursday after 2 p.m., or Saturday morning]. Please let me know which works best for you, or feel free to suggest an alternative.

Thank you for your prompt attention to this. I look forward to hearing from you with a confirmed repair time.

Sincerely,

[Your Full Name] [Unit Number] [Phone Number] [Email Address]

Quick tip: If your landlord is responsive to calls but not action, sending this via email creates a paper trail. If they still don’t act after this message, your next step would be a more formal written notice (and checking your local tenant rights about heat requirements), but this email keeps the door open for cooperation while making the urgency clear.

Here is a generic, TypeScript-friendly useDebounce hook. It returns the most recent value only after the specified delay has passed without a new change, and it automatically cancels any pending update when the component unmounts (or when the value changes again).

import { useState, useEffect } from 'react';

/**
 * Debounces a changing value. The returned value will only update after the
 * specified delay has elapsed without the source value changing.
 *
 * @template T The type of the value to debounce.
 * @param value The value to debounce.
 * @param delay The delay in milliseconds.
 * @returns The debounced value.
 */
export function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Cleanup cancels the timeout on unmount or when value/delay changes
    return () => {
      clearTimeout(timer);
    };
  }, [value, delay]);

  return debouncedValue;
}

Usage example

import { useState } from 'react';
import { useDebounce } from './useDebounce';

function SearchInput() {
  const [query, setQuery] = useState('');
  const debouncedQuery = useDebounce(query, 400);

  // This effect (or derived data) now reacts to the debounced value,
  // so it won't fire on every keystroke.
  useEffect(() => {
    if (debouncedQuery) {
      console.log('Searching for:', debouncedQuery);
    }
  }, [debouncedQuery]);

  return (
    <input
      type="text"
      value={query}
      onChange={(e) => setQuery(e.target.value)}
      placeholder="Search..."
    />
  );
}

How it works

1. Synchronization – useState initializes the debounced value to the current value, so the first render is immediate.

2. Timeout management – On every render where value or delay changes, useEffect starts a new setTimeout. If another change happens before the delay elapses, React runs the cleanup function from the previous effect, calling clearTimeout and canceling the stale update.

3. Unmount safety – When the component unmounts, React runs the final cleanup function, ensuring no state update occurs on an unmounted component.

The probability is only about 33% (roughly 1 in 3).

The math

Assuming “99% accurate” means the test is 99% sensitive (catches 99% of users) and 99% specific (correctly clears 99% of non-users, so 1% false positive rate):

Using natural frequencies with 10,000 people

• 50 people use the drug (0.5%)

• 9,950 people do not

True positives: 99% of 50 = ~49.5 False positives: 1% of 9,950 = ~99.5

Total positive tests: 49.5 + 99.5 = 149

$$\text{Probability} = \frac{\text{True positives}}{\text{All positives}} = \frac{49.5}{149} \approx \mathbf{33\%}$$

Why this surprises people

This result is a classic example of the base rate fallacy. Most people intuitively feel the answer should be near 99%. That intuition is wrong for three reasons:

1. Confusing the conditionals People mix up $P(\text{test}+ \mid \text{user})$ with $P(\text{user} \mid \text{test}+)$. The test being 99% accurate at detecting users does not mean that 99% of positive results are users. Those are very different numbers.

2. Ignoring the rarity of use Because only 0.5% of people use the drug, the non-using population is enormous (99.5%). A 1% false-positive rate applied to that huge group produces about twice as many false positives as true positives (~100 vs. ~50). The test is yelling “positive” at many innocent people simply because there are so many more innocent people to begin with.

3. Anchoring on “99% accurate” That number sounds almost certain, so our brains fail to adjust it downward for the prior probability. In reality, the positive test updates your belief from a 0.5% chance to a ~33% chance—a massive 66× increase—but it is far from a definitive diagnosis.

The broader lesson: When a condition is rare, even a highly accurate test can yield more false positives than true ones. That’s why doctors often don’t rely on a single screening test for rare diseases, and why context (base rates) matters as much as the test itself.