That had been their strategy, to just let Trump do things and become unpopular without drawing attention to themselves, but while Trump and Republicans have become less popular, Democrats' approval ratings have been sliding down as well (although they have a lead in the generic ballot) and polling indicates most Democratic voters think they're not doing enough to stop Trump. So, making a big show of "playing dirty" (threatening to gerrymander back in retaliation), and publicly saying that they'll no longer tie their hands behind their back, probably brings satisfaction to those people they're polling badly with. It's the kind of sentiment I've heard for years from online Democratic voters, and from people I know, but never was validated by the actual Democrats until now.

But ya, I guess “playing nice” is no longer in style, and taking the moral high ground (eg either CA’s non partisan redistributing process) is simply no longer viable or appreciated. Democrats have to show backbone…Or maybe we just need to find next Obama or Clinton (Bill not Hillary)…uninspiring leaders like Newsom aren’t going to do it, also AOC is old enough to run for president now, I think. Going slimy like Trump doesn’t feel right.

> Under current policy, the United States has about 20 years for corrective action after which no amount of future tax increases or spending cuts could avoid the government defaulting on its debt whether explicitly or implicitly (i.e., debt monetization producing significant inflation). Unlike technical defaults where payments are merely delayed, this default would be much larger and would reverberate across the U.S. and world economies.

My prediction is that the deficit will continue to increase, and so the default will come by then or sooner.

[0]: https://budgetmodel.wharton.upenn.edu/issues/2023/10/6/when-...

Don't think of the US (or any monetarily sovereign Government) as having the constraints of a household or business... It's fundamentally different and we make major errors (like the crazy idea the US would default) when we think of it in the wrong way...

> defaulting on its debt whether explicitly or implicitly (i.e., debt monetization producing significant inflation).

The real constraint isn’t solvency, it’s inflation and currency value. If deficits are monetized well beyond the economy’s capacity, inflation will rise and long term yields will climb, unless the central bank caps them, which then shifts the pressure to prices and the currency.

That's different from just saying the numbers are obviously being faked under Biden or whatever with no real evidence because you just feel like the economy is bad and assume corruption. Now there actually does seem to be corruption!

It's clearly just dismissive language that doesn't have to make sense. The only purpose is to make climate change seem like a fake concept thought of by groups with nefarious intentions. It's like asking the author of a short story what the main character's favorite color is. That detail simply wasn't considered because it's not needed in the short story.

The most expressive part of C is the syntax oriented around writing terse, side-effectful expressions that manipulate buffers, pointers and counters, with the array of precedences and the pre- and post-increments and assignment operators and short-circuiting operators. You can write stuff like this:

  while (--n > 0 && (c = getchar()) != EOF && (*s++ = c) != '\n')
      ;
  *s = '\0';

  // Parsing flags for command line arguments
  while (--argc > 0 && (*++argv)[O] == '-')
      while (c = *++argv[O])
          switch (c) {
          // ...
          }

  // Last line of a buffered `getchar()` implementation 
  return (--n >= 0) ? (unsigned char) *bufp++ : EOF;

  assert(i <= j);
  for (;;) {
      do_something_with(i);
      if (i == j)
          break;
      i++;
  }

You're reminding me of the book "Modern Compiler Design." The author goes over how to compile a general Pascal-style for-loop correctly, accounting for increasing or decreasing ranges, differing step sizes, and accounting for overflow. It was written using just goto statements, so I adapted a version of it to C. Just replace "intN_t" with an actual integer size. It works by calculating the number of times the loop will run. If "from" is equal to "to," it's still going to run at least once. Again, this is not mine, just adapted from the author's code (Dick Grune's).

  // enumerate: print out numbers from "from" to "to", inclusive, with step size "by"
  void enumerate(intN_t from, intN_t to, intN_t by) {
      uintN_t loop_count;
      intN_t i;
      if (by > 0) {
          if (from > to) return;
          loop_count = (to - from) / by + 1;
      } else if (by < 0) {
          if (from < to) return;
          loop_count = (from - to) / -by + 1;
      } else /* (by == 0) */ {
          // Maybe some kind of error
          return;
      }
      for (i = from; ; i += by) {
          printf("%d\n", i);
          if (--loop_count == 0) break;
      }
  }

Having an advanced type system does seem to encourage this sort of informal proof oriented thinking more than imperative and somewhat typeless languages do, though, since preconditions and postconditions and loop invariants and inductive proofs on loops are things you have to do yourself entirely in your head.