Here's a draft you can adapt. I've left placeholders in brackets.

Subject: Heating repair at [address] – request for a firm repair date

Dear [Landlord's name],

I'm writing about the heating at [address], which has not been working since [date], now just over three weeks ago. I first reported it on [date] by [phone/email/text] and followed up on [dates].

I understand repairs can take time to arrange, and I appreciate that you may be waiting on a contractor or parts. However, three weeks without heating is a significant problem, especially at this time of year, and I'd like to get it resolved as soon as possible.

Could you please confirm, by [date – e.g., end of this week]:

1. What the cause of the fault is, if known;

2. The name of the contractor or engineer handling the repair; and

3. A specific date when the repair will be carried out.

If it would help, I'm happy to arrange access at short notice, including evenings or weekends, so that scheduling isn't a barrier.

I'd much prefer to sort this out directly with you rather than take it further. If I don't hear back by [date], though, I'll need to look into the other options available to me, which may include contacting [the local council's housing department / a tenants' advice service / the relevant housing authority]. I'm mentioning this so that you know where things stand, not because I expect it to come to that.

Thank you for your attention to this. I look forward to hearing from you.

Kind regards, [Your name] [Phone number] [Address / flat number]

A few notes on using this:

• Keep the paper trail. Send it by email (or whatever leaves a record), and keep copies of your earlier messages. If you've only called so far, this email becomes the written record.

• Fill in the dates precisely. Specific dates make the timeline hard to dispute and show you've been patient.

• The "options" line is deliberately mild. It signals you know your rights without threatening. If you'd rather keep it softer still, you can delete that paragraph entirely for this round and add it only if you get no reply.

• Check local rules before escalating. Heating is usually treated as an essential service, and in many places landlords must fix it within a set period. Your local council or a tenants' advice line can tell you what applies to you and whether you have any right to withhold rent or arrange the repair yourself — don't do either without checking first, as it can backfire.

• Offer access and be flexible. This removes the most common excuse for delay and shows you're being reasonable.

If you tell me where you're based or how the earlier conversations went, I can adjust the tone or the escalation wording.

Here is a polite, professional, and firm email template. It avoids threatening language while clearly stating that the wait time has become unacceptable and requires immediate action.

Subject: URGENT: Heating repair follow-up – [Your Apartment/Unit Number]

Dear [Landlord's Name],

I hope you are having a good week.

I am writing to follow up on my previous messages from [Date of first request] regarding the broken heating in my unit. As it has now been three weeks without heat, the apartment is becoming increasingly uncomfortable to live in, especially as the temperatures drop.

I understand that scheduling contractors and sourcing parts can sometimes cause delays, and I appreciate your efforts so far. However, because working heat is an essential service, we really need to get this resolved as soon as possible.

Could you please provide me with a firm date and time for when a technician will be here to complete the repair?

If your usual HVAC technician is backed up, I would be more than happy to help coordinate with an alternate local company to get someone out here this week. Additionally, if the repair cannot be completed within the next 48 hours, could you please provide space heaters for the unit in the meantime?

Thank you for your prompt attention to this matter. I look forward to hearing from you by the end of the day tomorrow so we can get this scheduled.

Best regards,

[Your Name] [Your Apartment/Unit Number] [Your Phone Number]

Why this works:

• Creates a paper trail: Mentioning the exact date you first reported the issue subtly reminds them of their legal obligation to make timely repairs without sounding like a lawyer.

• Offers solutions, not just complaints: Offering to coordinate with a different repair company removes their excuse of "my usual guy is busy."

• Asks for temporary relief: Asking for space heaters signals that the unit is currently uninhabitable, while giving them an immediate, easy way to help you.

• Sets a deadline for a response: Asking to hear back "by the end of the day tomorrow" creates urgency and prevents them from putting your email on the back burner again.

Here's a typed useDebounce hook. It returns the debounced value and clears the pending timer whenever the input changes or the component unmounts, so you never get a state update on an unmounted component.

import { useEffect, useState } from "react";

/**
 * Returns a debounced copy of `value` that only updates after `delayMs`
 * milliseconds have passed without `value` changing.
 *
 * The pending update is cancelled when `value` or `delayMs` changes,
 * and when the component unmounts.
 */
export function useDebounce<T>(value: T, delayMs: number = 300): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    const timeoutId: ReturnType<typeof setTimeout> = setTimeout(() => {
      setDebouncedValue(value);
    }, delayMs);

    // Cleanup runs before the next effect and on unmount.
    return () => {
      clearTimeout(timeoutId);
    };
  }, [value, delayMs]);

  return debouncedValue;
}

Usage

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

  useEffect(() => {
    if (!debouncedQuery) return;
    // Fire the request only after the user pauses typing for 400ms.
    fetch(`/api/search?q=${encodeURIComponent(debouncedQuery)}`);
  }, [debouncedQuery]);

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

Notes

• Generic T means it works for strings, numbers, objects, etc., with full type inference at the call site.

• ReturnType<typeof setTimeout> keeps the timer ID type correct in both browser (number) and Node (Timeout) environments.

• Cancellation on unmount comes for free from the effect cleanup — React calls it when the component unmounts, so setDebouncedValue is never invoked afterward.

• If you need an immediate update when delayMs is 0, you can short-circuit at the top of the effect with if (delayMs <= 0) { setDebouncedValue(value); return; }.

Here is a clean, generic useDebounce hook written in TypeScript. It automatically handles canceling the timeout both when the value/delay changes and when the component unmounts.

useDebounce.ts

import { useState, useEffect } from 'react';

/**
 * Custom hook that debounces a value.
 *
 * @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(() => {
    // Set a timeout to update the debounced value after the specified delay
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Cleanup function: cancels the timeout if the value or delay changes
    // before the timeout completes, OR if the component unmounts.
    return () => {
      clearTimeout(timer);
    };
  }, [value, delay]);

  return debouncedValue;
}

Example Usage

Here is how you can use it in a component (e.g., waiting for a user to stop typing before making an API call):

import React, { useState, useEffect } from 'react';
import { useDebounce } from './useDebounce';

export const SearchComponent: React.FC = () => {
  const [searchTerm, setSearchTerm] = useState<string>('');
  
  // Debounce the search term so it only updates 500ms after the user stops typing
  const debouncedSearchTerm = useDebounce<string>(searchTerm, 500);

  useEffect(() => {
    if (debouncedSearchTerm) {
      console.log(`Fetching API results for: ${debouncedSearchTerm}`);
      // Perform your API call here
    }
  }, [debouncedSearchTerm]);

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

Key Features:

1. Generics (<T>): It preserves the exact TypeScript type of whatever value you pass into it (strings, numbers, objects, arrays, etc.).

2. Unmount Safety: Because clearTimeout is returned in the useEffect cleanup function, React guarantees it will run if the component unmounts, preventing memory leaks and "state update on an unmounted component" warnings.

The answer: about 33%

Even though the test is "99% accurate," a person who tests positive has only roughly a 1-in-3 chance of actually using the drug.

The calculation (Bayes' theorem)

Assume "99% accurate" means the test correctly identifies 99% of users (sensitivity) and correctly clears 99% of non-users (specificity).

• P(user) = 0.005, P(non-user) = 0.995

• P(positive | user) = 0.99

• P(positive | non-user) = 0.01

$$ P(\text{user} \mid +) = \frac{0.99 \times 0.005}{0.99 \times 0.005 + 0.01 \times 0.995} = \frac{0.00495}{0.00495 + 0.00995} \approx 0.332 $$

The intuitive version: imagine 10,000 people

Of the ~150 people who test positive, only ~50 actually use the drug. So 50 / 150 ≈ 33%.

Why it surprises people

1. Base-rate neglect. People focus on the test's 99% accuracy and ignore how rare drug use is. Because non-users outnumber users 199-to-1, even a tiny 1% false-positive rate applied to that huge group produces more false positives than the test produces true positives from the small group of users.

2. Confusing two different conditional probabilities. "99% accurate" tells you P(positive | user) — if you use, you'll probably test positive. People intuitively flip this into P(user | positive) — if you test positive, you probably use. These are not the same thing, and the gap between them is entirely driven by the base rate. (This flip is sometimes called the "inverse fallacy" or, in courtrooms, the "prosecutor's fallacy.")

3. "99%" sounds like certainty. It feels like a 1% error rate should mean 1% of results are wrong. But the relevant question isn't "how often is the test wrong?" — it's "among the positive results, how many are wrong?" And that depends on what you're screening for.

The practical takeaway

This is why screening for rare conditions is almost always followed by a second, confirmatory test. A second independent 99%-accurate test on the ~150 positives would raise the probability of true use from 33% to about 98%, because the prior is no longer 0.5% — it's 33%.

The probability that the person actually uses the drug is 33.2% (or roughly 1 in 3).

This means that even with a 99% accurate test, a positive result is twice as likely to be a false alarm as it is to be a true positive.

Here is the breakdown of the math, followed by why our brains find this so hard to accept.

The Math (Made Simple)

While this is a classic application of Bayes' Theorem, it is much easier to understand using concrete numbers. Imagine we test a random population of 10,000 people.

1. Separate the users from the non-users:

• Users: 0.5% of 10,000 = 50 people actually use the drug.

• Non-Users: 99.5% of 10,000 = 9,950 people do not use the drug.

2. Test the 50 Users (True Positives):

• The test is 99% accurate, so it catches 99% of the 50 users.

• 0.99 × 50 = 49.5 people test positive.

3. Test the 9,950 Non-Users (False Positives):

• The test is 99% accurate, meaning it has a 1% failure rate. It will falsely accuse 1% of the innocent people.

• 0.01 × 9,950 = 99.5 people test positive.

4. Calculate the final probability:

• In total, 149 people got a positive test result (49.5 true + 99.5 false).

• Out of those 149 people, only 49.5 are actual drug users.

• 49.5 divided by 149 = 33.2%.

(Note: This assumes "99% accurate" means the test is 99% sensitive at catching users AND 99% specific at clearing non-users).

Why Does This Surprise People?

Most people intuitively guess the answer is 99%, or perhaps 98.5%. The real answer shocks people because of a well-documented psychological blind spot known as the Base Rate Fallacy (or Base Rate Neglect).

Here is why our intuition fails us:

1. We ignore the size of the pools When the human brain hears "99% accurate," it latches onto that number because it sounds like a near-certainty. Simultaneously, we ignore the "base rate" (the 0.5% of users). We forget that the 1% error rate is being applied to a massive group of non-users, while the 99% accuracy rate is being applied to a tiny group of actual users. 1% of a giant number is bigger than 99% of a tiny number.

2. We confuse the conditions People naturally confuse two very different probabilities:

• The probability of testing positive if you use the drug (99%).

• The probability of using the drug if you test positive (33.2%).

3. We are bad at dealing with percentages Evolutionary psychologists suggest that humans didn't evolve to understand percentages and probabilities; we evolved to understand tangible counts (like 3 out of 10 hunters). When the problem is framed as percentages (99%, 0.5%), almost everyone gets it wrong—including doctors and statisticians. When it is framed as frequencies (like the 10,000-person example above), the illusion disappears.

The Real-World Takeaway

This is why medical professionals and employers rarely rely on a single screening test for rare conditions or infrequent drug use. If someone tests positive on an initial screening, they are given a second, different test.

If that same person takes a second independent test and tests positive again, the "base rate" has now shifted from 0.5% to 33.2%, and the probability that they are a user skyrockets to 98%.