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]

Here's a draft you can adapt. It's firm about the deadline and the facts, but it keeps the tone cooperative, since that's usually what gets repairs done fastest.

Subject: Heating repair needed at [Property Address], reported [date]

Dear [Landlord's Name],

I'm writing about the heating at [property address], which has not been working since [date]. I first reported the problem on [date] by [phone/text/email], and I have followed up on [dates] without a repair being scheduled.

It has now been three weeks without heat. The apartment is [describe conditions briefly, e.g., "often below 60°F"], which is affecting our comfort and health, and I'd like to resolve this as quickly as possible.

Could you please:

1. Confirm by [date, e.g., 2 business days from now] when a technician will be coming to inspect and repair the heating system.

2. Let me know the name and contact details of the company doing the work, so I can coordinate access.

3. Tell me if you need anything from me, such as a specific time window or access to a particular room.

I'm happy to work around your schedule and make sure someone is available to let the technician in. If I don't hear back by [date], I'll need to explore my options under [local tenancy law / the terms of our lease], which may include contacting [local housing authority / code enforcement] to request an inspection.

Thank you for your prompt attention to this. I'd much prefer to get this resolved directly with you, and I appreciate your help.

Best regards, [Your Name] [Unit number, phone number]

Tips before sending:

• Keep a paper trail. Send this by email or a text so there's a written record, even if you've already called.

• Check your lease and local law for the repair deadline and what you're entitled to (repair-and-deduct, rent withholding, or reporting to the housing authority). Rules vary a lot by location, and the threat in the last paragraph should only name remedies that actually apply to you.

• Take photos or note the temperature with a dated thermometer reading. This helps if you escalate.

• Don't withhold rent until you've confirmed what's legal where you live.

If you tell me your city or country and the approximate temperature in the apartment, I can tailor the legal reference and the wording.

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.

import { useEffect, useState } from "react";

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

  useEffect(() => {
    const timeoutId = window.setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Runs before the next effect and on unmount, cancelling the pending update.
    return () => {
      window.clearTimeout(timeoutId);
    };
  }, [value, delay]);

  return debouncedValue;
}

Usage:

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

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

  useEffect(() => {
    if (debouncedQuery) {
      console.log("Fetching results for:", debouncedQuery);
    }
  }, [debouncedQuery]);

  const handleChange = (e: ChangeEvent<HTMLInputElement>) => {
    setQuery(e.target.value);
  };

  return <input value={query} onChange={handleChange} placeholder="Search..." />;
}

Notes:

• window.setTimeout returns a number, which avoids the NodeJS.Timeout vs. number type mismatch you can hit in mixed Node/browser TypeScript setups.

• Because the cleanup function clears the timer, a pending update never calls setDebouncedValue after unmount, so there is no state update on an unmounted component.

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.

The probability is about 33%, not 99%.

Setup. I'll assume "99% accurate" means the test correctly identifies users 99% of the time and correctly clears non-users 99% of the time.

• Prior: P(user) = 0.005

• P(positive | user) = 0.99

• P(positive | non-user) = 0.01

Bayes' theorem:

$$P(\text{user} \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$$

Counting people instead (out of 10,000):

• 50 users → about 49.5 test positive

• 9,950 non-users → about 99.5 test positive (false positives)

• Total positives ≈ 149, of which about 49.5 are actual users

So roughly 1 in 3 positive results is a true positive.

Why it surprises people:

1. Base-rate neglect. We focus on the test's 99% accuracy and ignore how rare the drug use is. Only 0.5% of people use the drug, so the pool of non-users is huge, and even a 1% false-positive rate applied to that pool produces many more false alarms than there are true users.

2. The error rates apply to different groups. The 1% false-positive rate applies to the ~99.5% who don't use the drug. The 99% sensitivity applies only to the 0.5% who do. The large group's small error rate can outweigh the small group's large hit rate.

3. Intuition treats the test result as the answer. Bayes' theorem combines the test result with the prior. Intuition often skips the prior.

The practical lesson: a positive result from a screening test for a rare condition is a reason for confirmation, not a diagnosis. Follow-up tests with a different method are standard for this reason. If the prevalence were 10% instead of 0.5%, the same test would give a positive result about 92% probability of being a true positive.