Subject: Heating repair at [property address] — outstanding for three weeks

Dear [Landlord's name],

I hope you're well. I'm writing to follow up on the heating at [property address/unit], which I first reported on [date]. It's now been three weeks without working heating, and despite [my messages on X and Y dates / my calls on X and Y], the repair hasn't yet been carried out or scheduled.

With the cold weather, this is becoming a genuine problem — [briefly note the impact, e.g., the flat is very difficult to keep warm and I'm concerned about the effect on my health]. I'd ask that this now be treated as urgent.

Could you please confirm by [date — e.g., within five working days] when a contractor will attend? I'm happy to be flexible with access and can make myself available [on these days / at short notice] if that helps.

I'd much rather resolve this directly with you than take it any further, and I'm confident we can get it sorted quickly. I'd really appreciate a reply confirming the plan, even if the appointment itself is a few days away.

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

Kind regards, [Your name] [Phone number]

A few quick tips:

• Fill in the specifics (dates you reported it, any responses received) — a clear timeline makes it harder to brush off.

• Give a concrete deadline rather than "as soon as possible"; a week is usually seen as reasonable.

• Keep everything in writing from here on. This email becomes your record if you do ever need to escalate to a tenants' advice service or local authority — hopefully you won't.

The tone stays cooperative throughout, but the deadline and the one line about "taking it further" signal you're serious without starting a fight.

Here's an email that keeps things professional and firm while making clear you expect action:

Subject: Follow-Up: Heating Repair Requested Three Weeks Ago – Unit [Your Apartment Number]

Dear [Landlord's Name],

I hope you're doing well. I'm writing to follow up on the heating issue in my apartment, which I first reported on [date] — three weeks ago today. As of this morning, the heating is still not working.

I understand that repairs can take time to schedule, but three weeks without heat in [current month/season] is a significant problem. Beyond the discomfort, temperatures in the apartment have dropped to a point that affects my ability to live there comfortably and, frankly, raises health and safety concerns.

I would appreciate the following:

1. A specific repair date — a firm appointment, not a general promise that someone will "stop by."

2. A temporary solution in the meantime if the repair will take longer (e.g., space heaters or a rent adjustment for the period without heat).

3. Confirmation in writing of the repair plan.

If I don't hear back with a scheduled repair date by [date — e.g., end of this week], I'll need to explore other options to resolve this, including [local housing authority / tenant rights resources] as applicable in [city/state].

I'd much prefer to settle this directly and simply, and I appreciate the good relationship we've had as tenant and landlord. Please let me know the repair date at your earliest convenience.

Thank you, [Your Name] [Apartment Number & Address] [Phone Number]

A few tips to strengthen your position without escalating:

• Send it in writing (email is good) — this creates a paper trail if you need it later.

• Attach or reference your original request ("as I mentioned in my text on Feb 3...").

• Check your local tenant laws — many jurisdictions legally require landlords to maintain heat, and some let you pay for repairs yourself and deduct from rent if the landlord is unresponsive. Mentioning you know your rights (the way the email does, gently) often motivates action.

• Keep the tone factual — dates, specifics, and clear requests. Avoid accusations like "you've been ignoring me."

Would you like me to adjust the tone (firmer or softer), or tailor it to your specific situation?

useDebouncedValue

import { useEffect, useState } from 'react';

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

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

    // Cleanup runs when value/delay changes AND on unmount
    return () => {
      clearTimeout(timer);
    };
  }, [value, delay]);

  return debouncedValue;
}

export default useDebouncedValue;

How it works

• Generic <T> — the hook preserves whatever type you pass in (string, number, a custom object, etc.), so the returned value is fully typed.

• Debouncing — every time value changes, the effect re-runs. The cleanup function clears the pending timer before a new one starts, so the state only updates once the value has been stable for delay milliseconds.

• Unmount safety — the same cleanup function runs when the component unmounts, cancelling any pending timeout. This prevents a setState call on an unmounted component (and the associated memory leak / React warning).

Usage example

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

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

  useEffect(() => {
    if (!debouncedQuery) return;

    // Only fires 300ms after the user stops typing
    fetch(`/api/search?q=${encodeURIComponent(debouncedQuery)}`)
      .then((res) => res.json())
      .then(console.log);
  }, [debouncedQuery]);

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

The input stays responsive on every keystroke, while the expensive operation (the API call) only runs after typing pauses.

useDebounce Hook

import { useEffect, useState } from "react";

/**
 * Returns a debounced copy of `value` that only updates
 * after `delay` ms have passed without `value` changing.
 * The pending timer is cancelled on unmount or re-render.
 */
function useDebounce<T>(value: T, delay: number = 500): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    // Start the timer whenever `value` changes
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Cleanup: cancels the timer if value changes again,
    // or if the component unmounts
    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

export default useDebounce;

Types explained

• <T> generic — the hook infers the type of whatever you pass in, so debouncing a string returns a string, an object stays that object type, etc.

• value: T — the reactive input.

• delay: number = 500 — optional, defaults to 500 ms.

• Return type T — same type as the input.

Usage example

function SearchBox() {
  const [query, setQuery] = useState<string>("");
  const debouncedQuery = useDebounce<string>(query, 300);

  useEffect(() => {
    if (debouncedQuery) {
      // Only fires 300ms after the user stops typing
      console.log("Fetching results for:", debouncedQuery);
    }
  }, [debouncedQuery]);

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

Key points

1. Cancel on unmount — the useEffect cleanup function runs clearTimeout(timer), so no state update is attempted after the component unmounts (avoiding the "setState on unmounted component" issue).

2. Re-render safety — cleanup also runs on every value change, which is exactly what makes debouncing work: a rapid typist keeps resetting the timer.

3. Generic type safety — useDebounce<string>(query, 300) or simply useDebounce(query, 300) (inferred) both work.

The answer: about 33%

Despite the positive result, there's only roughly a 1-in-3 chance the person actually uses the drug.

Working through it

Assume "99% accurate" means the test catches 99% of users (sensitivity) and correctly clears 99% of non-users (specificity). Now imagine testing 100,000 people:

Total positive tests: 495 + 995 = 1,490

$$P(\text{user} \mid \text{positive}) = \frac{495}{1{,}490} \approx 33\%$$

Same result via Bayes' theorem:

$$P(U \mid +) = \frac{0.99 \times 0.005}{0.99 \times 0.005 + 0.01 \times 0.995} = \frac{0.00495}{0.0149} \approx 0.33$$

Why it surprises people

1. Base rate neglect. People anchor on the 99% accuracy and ignore the 0.5% prevalence. But because users are so rare, the false positives (995) actually outnumber the true positives (495) two to one. A small error rate applied to a huge pool of non-users swamps the correct results from the tiny pool of users.

2. Confusing two different probabilities. People mix up:

• P(positive test | user) = 99% — what "accurate" means

• P(user | positive test) = 33% — what you actually want to know

These feel identical but are wildly different when the condition is rare.

3. Intuition treats the test as the whole story. The test result is evidence that updates a prior belief, not a verdict. A positive result on a rare condition is weak evidence; a positive result on a common one would be much stronger.

The practical upshot

This is exactly why confirmatory testing exists. If the same person takes a second, independent test and it's positive again, the probability jumps to about 98% — because you're now testing someone with a 33% prior, not 0.5%. It's also why screening entire populations for rare diseases inevitably generates many false alarms.

The Answer: About 33%

Despite the test being "99% accurate," the probability the person actually uses the drug is only ~1 in 3.

The Calculation (Bayes' Theorem)

Given:

• P(uses drug) = 0.5% = 0.005

• P(tests positive | uses) = 99% = 0.99

• P(tests positive | doesn't use) = 1% = 0.01 (false positive rate)

Applying Bayes' theorem:

$$P(\text{uses} \mid \text{positive}) = \frac{P(\text{positive} \mid \text{uses}) \cdot P(\text{uses})}{P(\text{positive} \mid \text{uses}) \cdot P(\text{uses}) + P(\text{positive} \mid \text{doesn't}) \cdot P(\text{doesn't})}$$

$$= \frac{(0.99)(0.005)}{(0.99)(0.005) + (0.01)(0.995)} = \frac{0.00495}{0.00495 + 0.00995} \approx 0.332$$

Intuitive Version: Think in Numbers

Imagine 10,000 people tested:

So about 149 people test positive, but only ~50 of them are actual users. That's roughly 33%.

Why It Surprises People: The Base Rate Fallacy

Most people focus on the "99% accurate" figure and ignore the base rate — the fact that users are extremely rare (0.5%).

The key insight: false positives come from a much larger pool. Even though the false positive rate is small (1%), it applies to the 99.5% of people who don't use the drug. So false positives (99.5 people) actually outnumber true positives (49.5 people) two to one.

Our intuition treats "the test is 99% accurate" as if it means "a positive result is 99% correct" — but those are entirely different quantities. The test's accuracy in detecting users says nothing directly about how much to trust a positive result, which depends critically on how rare the condition was to begin with.

Practical implication: In mass screening for rare conditions (drugs, diseases, terrorism watchlists), a positive result alone is often weak evidence — confirmatory testing is essential.