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]

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

Dear [Landlord's Name],

I hope you are having a good week.

I am writing to follow up on the heating issue in [Unit/Apartment Number], which was first reported on [Date of first message, e.g., October 12th]. It has now been three weeks since the heat stopped working, and the issue remains unresolved.

With the temperatures dropping, the apartment has become uncomfortably cold and difficult to live in. While I appreciate that coordinating maintenance can sometimes take time, three weeks without heat is a pressing issue that needs immediate attention.

Could you please confirm by [Day of week, e.g., tomorrow at 5:00 PM] when a technician will be arriving to complete the repair?

I am happy to make myself available or provide permission for entry so this can be resolved as quickly as possible.

Thank you for your prompt attention to this matter. I look forward to your update.

Best regards,

[Your Name] [Your Phone Number] [Your Apartment Number]

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.

Here is a complete, typed useDebounce hook. It uses a generic type T so it works with any data type (strings, objects, numbers, etc.) and cancels the timer if the value changes or when the component unmounts.

The Hook

import { useState, useEffect } from 'react';

/**
 * Custom hook that debounces a value.
 * Cancels pending timeouts when the value changes or on component unmount.
 *
 * @param value The value to be debounced.
 * @param delay The debounce delay in milliseconds (default: 500ms).
 * @returns The debounced value.
 */
export function useDebounce<T>(value: T, delay: number = 500): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    // Set up the timer to update the value after the delay
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // React runs this cleanup function:
    // 1. Before re-running the effect when `value` or `delay` changes.
    // 2. When the component unmounts.
    return () => {
      clearTimeout(timer);
    };
  }, [value, delay]);

  return debouncedValue;
}

Example Usage

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

export const SearchComponent: React.FC = () => {
  const [searchTerm, setSearchTerm] = useState<string>('');
  
  // Debounce the input by 300ms
  const debouncedSearchTerm = useDebounce<string>(searchTerm, 300);

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

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

How cancellation works:

The return () => clearTimeout(timer); inside useEffect is React's native cleanup mechanism. React guarantees this cleanup function runs whenever the component is removed from the DOM (unmounted), preventing state updates on unmounted components and memory leaks.

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.

If someone tests positive, the probability that they actually use the drug is approximately 33.2% (or roughly 1 in 3).

Here is the step-by-step breakdown of the math and the psychological reason why this result is so counterintuitive.

The Math (Using a Concrete Example)

The easiest way to understand this is to imagine a population of 10,000 people:

1. How many people actually use the drug?

   • 0.5% of 10,000 = 50 people are drug users.

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

2. What happens when the 50 drug users take the test (99% accuracy)?

   • True Positives: $99\% \times 50 = \mathbf{49.5\text{ people}}$ test positive.

   • False Negatives: 0.5 people test negative.

3. What happens when the 9,950 non-users take the test (1% error rate)?

   • False Positives: $1\% \times 9,950 = \mathbf{99.5\text{ people}}$ test positive.

   • True Negatives: 9,850.5 people test negative.

4. Calculate the probability:

   • Total positive tests = $49.5 + 99.5 = \mathbf{149\text{ total positive tests}}$.

   • Of those 149 positive tests, only 49.5 are actual users.

$$\text{Probability} = \frac{49.5}{149} \approx 0.3322 \text{ (or } \mathbf{33.2\%}\text{)}$$

Even with a positive test, there is roughly a 67% chance the person is clean.

Why Does This Surprise People?

This counterintuitive result is caused by a cognitive bias known as the Base Rate Fallacy (or Base Rate Neglect).

• People focus on the test, not the population: Humans naturally anchor on the "99% accurate" figure and assume a positive test means a 99% chance of guilt.

• The power of small percentages on large groups: Non-users make up the overwhelming majority of the population (99.5%). Even though the test's error rate is tiny (just 1%), 1% of a huge group (99.5 people) produces more positive results than 99% of a tiny group (49.5 people).

In short, false positives end up outnumbering true positives roughly 2 to 1, which catches most people off guard.