Here’s a copy-paste draft that is clear about the problem and deadline, but keeps the tone cooperative:

Subject: Urgent follow-up: No heating for 3 weeks at [Your Address / Unit #]

Dear [Landlord's Name],

I hope you're well. I'm writing to follow up on the heating issue at [Your Full Address, including Unit # if applicable].

I first reported this on [Date - e.g., October 12th], and have followed up on [Date 2] and [Date 3], but the heating is still not working. It's now been three weeks without heat, which has made the property very cold and difficult to live in, especially overnight.

I understand repairs can take time to arrange, and I appreciate your help with the property so far. I would like to get this resolved amicably as soon as possible.

Could you please let me know by [tomorrow / specific date] what the plan and timeline is for the repair? I would appreciate it if the repair could be completed by [specific date, e.g., Friday, November 6th].

I’m happy to provide access for a contractor. I’m generally available on [list 2-3 days/times, e.g., weekdays after 4pm and weekends], but let me know what works and I’ll do my best to accommodate.

If there will be a further delay, please let me know if you can provide a temporary solution such as portable heaters in the meantime.

Thank you very much for your prompt attention to this. Please reply to this email so we have everything in writing.

Best regards, [Your Full Name] [Your Address] [Your Phone Number]

Quick tips to get the repair, not a fight:

1. Fill in the dates. Listing when you first reported it makes it firm without sounding aggressive.

2. Send it in writing. Email is perfect — it creates a paper trail. Keep copies of your previous messages too.

3. Give a reasonable deadline. 3-5 days from sending is firm but fair, and offering access times shows you're cooperating.

Want me to tailor this with your actual dates and details?

Subject: Heating repair—request for confirmed completion date

Dear [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 is still not working. This is affecting my ability to live comfortably in the property and needs to be resolved promptly.

Please confirm by [date] when a qualified technician will attend and when the repair is expected to be completed. If there is a delay with parts or scheduling, please let me know what temporary heating arrangements you can provide in the meantime.

I’d like to resolve this cooperatively. My priority is simply to have reliable heating restored, and I’m happy to coordinate access to help get the work done.

Thank you for your prompt attention. I look forward to receiving a confirmed plan.

Kind regards, [Your Name] [Property Address]

Here's a clean, typed useDebouncedValue hook. The clearTimeout in the useEffect cleanup runs both when value changes and when the component unmounts, so it never sets state after unmount.

Create hooks/useDebouncedValue.ts:

import { useEffect, useState } from 'react';

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

  useEffect(() => {
    // Schedule update
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Cancel if value/delay changes, or on unmount
    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]);

  return debouncedValue;
}

Usage

import { useEffect, useState } from 'react';
import { useDebouncedValue } from './hooks/useDebouncedValue';

function SearchInput() {
  const [query, setQuery] = useState<string>('');
  const debouncedQuery = useDebouncedValue<string>(query, 300);

  useEffect(() => {
    if (!debouncedQuery) return;
    // fetch results with debouncedQuery
    console.log(debouncedQuery);
  }, [debouncedQuery]);

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

How it works:

1. Stores the debounced copy in useState

2. On every value change, starts a new setTimeout

3. The cleanup cancels the previous timeout, preventing stale updates and set-state-after-unmount

import { useEffect, useState } from "react";

/**
 * Returns the value after it has stopped changing for `delayMs`.
 * Cancels pending updates when the value/delay changes or on unmount.
 */
export function useDebouncedValue<T>(value: T, delayMs: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(() => value);

  useEffect(() => {
    const timeoutId = setTimeout(() => {
      // The wrapper also supports function-valued T.
      setDebouncedValue(() => value);
    }, delayMs);

    return () => {
      clearTimeout(timeoutId);
    };
  }, [value, delayMs]);

  return debouncedValue;
}

Usage:

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

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

  return (
    <div>
      <input
        value={query}
        onChange={(event) => setQuery(event.target.value)}
        placeholder="Search…"
      />
      <p>Debounced query: {debouncedQuery}</p>
    </div>
  );
}

The initial value is returned immediately. Subsequent changes are delayed until delayMs has elapsed without another change; effect cleanup cancels the pending timer on unmount.

This is the classic Bayes' Theorem surprise — about 33%, not 99%.

We assume "99% accurate" means:

• If you use the drug, 99% chance you test positive: P(Positive | User) = 0.99

• If you don't use, 99% chance you test negative: P(Negative | Non-User) = 0.99, so P(Positive | Non-User) = 0.01

And the base rate is: P(User) = 0.005 (0.5%), P(Non-User) = 0.995

The math

We don't want P(Positive | User). We want the reverse: P(User | Positive).

P(User | Positive) = P(Positive | User) * P(User) / P(Positive)

where:

P(Positive) = P(Positive | User)*P(User) + P(Positive | Non-User)*P(Non-User)
            = 0.99*0.005 + 0.01*0.995
            = 0.00495 + 0.00995
            = 0.0149

So:

P(User | Positive) = 0.00495 / 0.0149
                   ≈ 0.332
                   ≈ 33%

A positive test means roughly a 1 in 3 chance they actually use the drug.

The intuition with 10,000 people

Forget formulas, count people:

1. Out of 10,000 people, 50 are users (0.5%), 9,950 are non-users.

2. Of the 50 users, 99% test positive: ~49 true positives.

3. Of the 9,950 non-users, 1% test positive falsely: ~100 false positives.

Total positives = 49 + 100 = ~149

True positives = 49 out of 149 ≈ 1/3.

Even though the false positive rate is tiny (1%), there are so many more non-users than users (199 to 1) that the false positives swamp the true positives.

Why does it surprise people?

1. We confuse the two directions. 99% is P(Positive | User), but we hear it as P(User | Positive). They are not the same. This is sometimes called the prosecutor's fallacy.

2. We ignore the base rate — Base Rate Neglect. Our brain focuses on "99% accurate test" and ignores "only 0.5% of people use it." Intuitively we act as if it's 50/50 whether someone uses the drug before the test.

When a condition is rare, even a very good test will produce mostly false positives. That's why we don't screen whole populations for rare diseases/drugs with a single test — you need a second, confirmatory test.

In fact, if this same person tested positive twice in a row (with independent tests), the probability would jump to about 98%.

About 33.2%—assuming “99% accurate” means both 99% sensitivity and 99% specificity. That is, the test detects 99% of users and correctly gives a negative result to 99% of non-users.

Imagine testing 20,000 people:

Of the 298 positive results, only 99 are from actual users:

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

Why it surprises people: We tend to confuse “the test is positive in 99% of users” with “99% of people who test positive are users.” Those are different probabilities. Because non-users vastly outnumber users, even a 1% false-positive rate produces more false positives than true positives. Ignoring this imbalance is called base-rate neglect.

If “99% accurate” refers only to overall accuracy, rather than sensitivity and specificity separately, there isn’t enough information to calculate the answer.