Subject: Heating Repair Request – [Your Address, Unit #] – Unresolved for Three Weeks

Dear [Landlord's Name],

I hope you're doing well. I'm writing to follow up on the heating issue at [address, unit number], which I first reported on [date of first report] and have mentioned again on [dates of follow-ups]. As of today, the heating has been non-functional for three weeks.

With winter temperatures, this has become a serious concern for the habitability and safety of the unit. I'd really like to work with you to get this resolved as quickly as possible.

To make scheduling easy, here is my availability for a repair visit:

• [Day/date/time window]

• [Day/date/time window]

• [Day/date/time window]

I'm happy to provide access at other times with a day's notice, and I can be reached at [phone number] or this email address.

If there's anything you need from me to move this forward—whether it's scheduling flexibility, coordination with a technician, or additional photos of the issue—please let me know. My goal is simply to have working heat as soon as possible.

Could you please confirm by [date, e.g., 48 hours from now] that a repair has been scheduled? If I don't hear back, I'll follow up again, and I may need to explore the repair options available to tenants under [your state/city]'s habitability standards. I'd much prefer to handle this directly with you.

Thank you for your attention to this—I appreciate your help.

Best regards, [Your Name] [Phone Number] [Unit/Address]

A few tips:

• Keep a paper trail. This email itself is documentation. If you've called or talked in person before, note those dates in the email (as placeholders above).

• Be specific but not emotional. The tone above is cooperative, while still putting a deadline and flagging your rights without issuing a threat.

• Save everything. Screenshot the sent email, keep any replies, and note the indoor temperature if it's dangerously cold.

• Check your local rules. Some jurisdictions allow tenants to "repair and deduct" or withhold rent after proper notice. Mentioning this lightly (as the email does) often motivates action without escalating.

Want me to adjust the tone (warmer, shorter, more formal) or tailor it to a specific situation?

Subject: Request to resolve heating issue promptly

Hi [Landlord’s Name],

I’m following up on the heating issue I first reported on [date]. It has now been three weeks, and the heating still isn’t working. Being without reliable heat for this long has been difficult, and I need the repair to be treated as a priority.

Please confirm by [date/time] when a qualified technician will attend and when you expect the heating to be fully restored. If there will be any further delay, please arrange a safe temporary heating solution in the meantime.

I’m happy to coordinate access to help get this resolved quickly. My goal is simply to have working heating and a clear timeline for the repair.

Thank you for your prompt attention. I look forward to your confirmation.

Best, [Your Name] [Property Address / Unit Number]

import { useEffect, useState, useRef } from 'react';

/**
 * Debounces a value so it only updates after a specified delay of
 * no further changes. The pending timer is cancelled on unmount.
 *
 * @template T  The type of the value being debounced.
 * @param value     The value to debounce.
 * @param delayMs   Delay in milliseconds (default: 300).
 * @returns The debounced value (updates only after `delayMs` of silence).
 */
function useDebouncedValue<T>(value: T, delayMs: number = 300): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);
  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);

  useEffect(() => {
    // Cancel any pending timeout when value changes or on unmount
    if (timerRef.current !== null) {
      clearTimeout(timerRef.current);
    }

    timerRef.current = setTimeout(() => {
      setDebouncedValue(value);
    }, delayMs);

    // Cleanup runs on every re-run (value change) AND on unmount
    return () => {
      if (timerRef.current !== null) {
        clearTimeout(timerRef.current);
      }
    };
  }, [value, delayMs]);

  return debouncedValue;
}

export default useDebouncedValue;

How it works

Usage example

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

function SearchBar() {
  const [query, setQuery] = useState('');
  const debouncedQuery = useDebouncedValue(query, 500);

  // Only runs when the user pauses typing for 500 ms
  useEffect(() => {
    if (!debouncedQuery) return;
    fetchResults(debouncedQuery);
  }, [debouncedQuery]);

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

Optional: debounce a callback instead

If you need to debounce a function call rather than a value (e.g. an event handler), here is a companion hook that also cancels on unmount:

import { useEffect, useRef, useCallback } from 'react';

function useDebouncedCallback<A extends unknown[]>(
  callback: (...args: A) => void,
  delayMs: number = 300
): (...args: A) => void {
  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const callbackRef = useRef(callback);

  // Keep the latest callback without re-creating the debounce timer
  useEffect(() => {
    callbackRef.current = callback;
  }, [callback]);

  // Cancel pending call on unmount
  useEffect(() => {
    return () => {
      if (timerRef.current !== null) {
        clearTimeout(timerRef.current);
      }
    };
  }, []);

  return useCallback(
    (...args: A) => {
      if (timerRef.current !== null) {
        clearTimeout(timerRef.current);
      }
      timerRef.current = setTimeout(() => {
        callbackRef.current(...args);
      }, delayMs);
    },
    [delayMs]
  );
}

This variant uses callbackRef to always invoke the latest version of the callback while keeping the debounce timer stable, and tears down the timer in a dedicated unmount cleanup.

import { useEffect, useState } from "react";

export function useDebouncedValue<T>(value: T, delayMs: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    const timeoutId = setTimeout(() => {
      // The wrapper also supports values that are themselves functions.
      setDebouncedValue(() => value);
    }, delayMs);

    // Cancel the pending update when dependencies change or on unmount.
    return () => clearTimeout(timeoutId);
  }, [value, delayMs]);

  return debouncedValue;
}

Usage:

function SearchInput() {
  const [query, setQuery] = useState("");
  const debouncedQuery = useDebouncedValue(query, 300);

  useEffect(() => {
    // Run your search using debouncedQuery.
    console.log("Search:", debouncedQuery);
  }, [debouncedQuery]);

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

The initial value is returned immediately. Subsequent changes are applied after delayMs without another change; pending timers are cleared on unmount.

The False Positive Paradox

Setting Up the Problem

Applying Bayes' Theorem

Imagine a population of 10,000 people:

• 50 are drug users (0.5% of 10,000)

• 9,950 are not drug users

Now run the tests:

Total positives: 50 + 99 = 149

$$P(\text{user} \mid \text{positive}) = \frac{50}{149} \approx \textbf{33\%}$$

The probability the person actually uses the drug is only about 1 in 3.

Why This Surprises People

People intuitively think "99% accurate → 99% chance they're a user." The trap is ignoring the base rate:

1. True positives are rare because users are rare (50 out of 10,000).

2. False positives are abundant because non-users are the vast majority (99 out of 10,000 falsely flagged).

3. Even though the false positive rate is tiny (1%), it applies to ~200× more people than the true positive rate.

This is the base rate fallacy: we over-focus on the test's accuracy and under-weight how unlikely the condition was to begin with. The 99% accuracy describes how well the test performs within each group — it does not tell you the chance that a positive result means you have the condition.

Key takeaway: When a condition is rare, even highly accurate tests produce mostly false alarms. The prior probability matters enormously.

About 33.2%, assuming “99% accurate” means both:

• 99% of drug users test positive.

• 99% of non-users test negative.

Imagine testing 20,000 people:

Of the 298 positive results, only 99 come from drug users:

[ P(\text{uses drug}\mid\text{positive})=\frac{99}{99+199}\approx \boxed{33.2\%}. ]

Why it surprises people: We tend to confuse “a user has a 99% chance of testing positive” with “someone who tests positive has a 99% chance of being a user.” Because drug use is rare, the much larger non-user population produces more false positives than true positives—even with a small false-positive rate. Ignoring that prevalence is called the base-rate fallacy.

If “99% accurate” means only overall accuracy, there isn’t enough information to calculate the probability.