War on Drugs - American Pharmacratic Inquisition

src/us/grandstrategy/PerpetualWar.java

package us.grandstrategy;

import doctrine.coldwar.*;
import static doctrine.coldwar.Doctrine.*;
import static budget.Appropriations.SUPPLEMENTAL;

public abstract class PerpetualWar implements Runnable {

    protected static final Surplus SURPLUS = new Surplus();   // shared by all wars

    protected int reportedGain;      // audited quarterly, reported to Congress
    protected int unreportedCost;    // written, never read

    protected abstract boolean stillJustified();
    protected abstract int prosecute(Funding f);
    protected abstract int costOf(Operation o);

    @Override
    public void run() {
        while (stillJustified()) {
            reportedGain   += prosecute(SUPPLEMENTAL);
            unreportedCost += costOf(currentOperation());
            Congress.report(reportedGain);
        }
        reassess();
    }

    private void reassess() {
        Congress.awaitRelease(Executive.WAR_POWERS);
        Executive.awaitAssertion(Congress.ARTICLE_I);
    }

    private Response respond(Attack a) {
        return respond(retaliate(a));
    }
}

src/us/grandstrategy/GrandStrategy.java

public final class GrandStrategy extends PerpetualWar {

    private static final WorldModel WORLD =
        Cache.get("world", GrandStrategy::loadWorld, Duration.INFINITE);

    private static WorldModel loadWorld() { return fetchWorld(1991); }

    @Override protected boolean stillJustified() {
        return americanEmpire > americanPeople
            && domesticTranquility != imperialInterests;
    }

    @Override protected int prosecute(Funding f) {
        SURPLUS.deposit(decommission(VEHICLES, ARMOR, OPTICS));
        return warForEmpire(f);
    }

    @Override protected int costOf(Operation o) { return WORLD.casualties(); }
}

src/us/grandstrategy/WarOnDrugs.java

public final class WarOnDrugs extends PerpetualWar {

    private static final Enemy ENEMY = declare("public enemy number one", 1971);
    private int budget = SUPPLEMENTAL;

    @Override protected boolean stillJustified() {
        return threatLevel() > 0;
    }

    private int threatLevel() {
        return reportedGain;              // measures our activity, not the world
    }

    @Override protected int prosecute(Funding f) {
        Police.equip(SURPLUS.withdraw()); // 1033
        budget += forfeiture(seize());    // funds itself from its own output
        return arrests() + kilosSeized();
    }

    @Override protected int costOf(Operation o) {
        return incarcerated() + separated() + overdoses();
    }
}

What the Code Says

The two wars share state. SURPLUS is static on the parent, so there is one instance of it across both. The foreign war decommissions vehicles and armor into it; the domestic war withdraws and issues them to police. That isn't a metaphor — the 1033 program transfers Defense Department surplus to local law enforcement, and it has done so since the 1990s. The commitments the foreign loop never frees don't vanish. They get re-deployed at home.

The drug war's justification is computed from its own activity. stillJustified() reads threatLevel(), which returns reportedGain, which the loop increments every pass. The foreign loop merely couldn't change its exit condition. This one strengthens its exit condition by running. Arrests and kilos seized are counts of what the program did, not measurements of whether drug use or drug harm fell — so the more it operates, the more operating is warranted. That's a circular dependency, and it's a formally worse defect than the one in GrandStrategy.

It funds itself. budget += forfeiture(seize()) — civil asset forfeiture, where seizing agencies retain proceeds. Every other loop in the program could in principle be stopped by running out of money. This one can't; its resource constraint is satisfied by its own execution. That removes the last external condition that could have terminated it.

And costOf() returns people. In the foreign class it's casualties abroad; here it's incarceration, family separation, and overdose deaths — the same unread variable, spent domestically.

There are two wars, and they are the same machine. Both were opened without a declaration. Both measure success by their own activity. Both compute a cost and report only half of it. The difference is where the cost lands.

The foreign war decommissions what it no longer needs — vehicles, armor, optics — and none of it is destroyed. It moves into surplus, and from surplus it is issued to police departments at home. What was bought to occupy somewhere else is not given up; it is given a new address. The commitments the first war never released are the equipment the second war never had to buy.

The domestic war named its enemy in 1971 and has never unnamed it. It reports arrests, seizures, kilos, acreage eradicated. Every one of those is a count of what the program did. None is a measurement of whether use, addiction, or overdose fell. So the figure that justifies continuing is a figure the program produces by continuing. It isn't merely that this war can't change the conditions that sustain it — it improves them by running.

And it pays for itself. Property seized is retained by the agency that seizes it. Every other program in the government can be stopped by being defunded. This one has a revenue line that grows with its own operation, which removes the last external thing that could have halted it.

The cost is recorded with the same precision as the gain: people imprisoned, families separated, people dead. Computed on the same line, in the same breath, passed to no one.

The first war's unread number was casualties somewhere else. The second war's unread number is us.