Congressional Cowardice

I am unforgiving of GOP Congressional cowardice. They pledged an oath to support and defend the Constitution. They have historically sent millions into war, the sometimes-tenuous justification being a need to defend our way of life. There is now a coup afoot and it falls to Congress itself to defend us.

Any in Congress sustaining the coup because they fear for their job, their safety or the safety of their family are committing treason.

Protecting and defending the US is not optional, something to do if it's convenient. It is a sworn duty.

Their paid job is to represent the citizens who elected them—not party, not billionaires, not the President.

Why may Congress be more selfish than soldiers they send to battle?

Why are their families entitled to protection at the expense of our nation?

We know they speak privately of being afraid, but we citizens are afraid, too, and we have no recourse.

These people swore to act on our behalf.

These treasonous cowards of the GOP Congress, by their corrupt, selfish, and dishonorable action and inaction are, at every opportunity, unilaterally surrendering the Constitution they swore to protect, willfully ignoring that it leads us inevitably to authoritarian rule.

The cowardly GOP Congress plainly hope that passively turning a blind eye to a coup, ignoring their oath and instead pledging fealty to a would-be dictator, will leave them spared his wrath.

Yet dictators need neither Congress nor Courts. They make their own laws and brook no checks on their power.

We are all afraid. I do not forgive the GOP Congress their fear. I expect them to rise above it. Selfish action now is beyond shameful, beyond corrupt. Traitorous. No better than a deserter, AWOL from a post at a time when necessity and duty requires defending the Constitution and the nation.

If the GOP Congress won't do their job, they should step down and go cower in their basement as private citizens.

Even an empty seat could change the balance of power, allowing others to do THEIR job, tipping things enough to save us from autocracy.

Please, do at least that for the Constitution.

 

---

Author's Notes:

If you got value from this post, please “Share” it.

This post originated as a thread on BlueSky. I've done very light editing of content and formatting, but the essential content is mostly unchanged.

The image of the Constitution is in the public domain, and was obtained from Wikipedia. The flames overlaid on it were added by me using Gimp. The flames were created from Abacus.ai using Claude Sonnet 3.5 and Flux 1.1 Ultra Pro, though I had such great difficulty getting it to give me a real-looking Constitution, without confabulating other text, that I had to just ask for the flames and merge things myself.

Some Hurried Thoughts

Given that people aren't always mindful about what they do, sometimes almost preferring that people make suggestions they can just passively agree to, it's quite a responsibility to make really casual choices sometimes.

For example, in Facebook, the choice of metaphor where we call people “friends” if we connect to them socially there has some amazing ramifications. People dither endlessly about whether to “unfriend” someone, or they lament being “unfriended.” These follow from the choice, though, for the system to refer to these people as in fact friends, like we have in real life. It's a weighty decision to make someone a friend, and a lot of work to hold a friendship.

But what if Facebook had called them “guests” instead? What if the metaphor had been that of a dinner party? Would our expectations of them be different? They'd be the same people with the same capabilities. Would it seem like the same huge thing to disinvite someone, or to ask them to leave the party? People do this, and friendships survive. Also, people invite people who are not really full-fledged friends to a party. Our expectations guide us in weird ways. I've come to think of people I'm connected to on Facebook as my party guests, and it leaves me feeling freer to not worry it's so heavyweight to decide that maybe they weren't right for this party.

In fact, though, I wanted to talk about computer keyboards. There are some subtle and interesting influences there. Some keyboards have a notion of BACKSPACE or DELETE, as well as arrow keys. So people rush to make editing commands that make use of these. There isn't always just one single interpretation, so some keys are jump-off points for imagination.

I used to use Lisp Machines decades ago. Special computers that had support for the Lisp programming language in hardware. But they also had interesting keyboards that were evocative in various ways, with fanciful keys labeled SUSPEND, RESUME, ABORT, etc., as well as even stranger keys like ones with roman numerals (I through IV) or with thumbs pointing in various directions (up, down, left, right).

The SUSPEND key was interesting because it strongly suggested the need to suspend a program in the middle, that one might later RESUME. ABORT presumed you needed to stop things, as often the ESC (“Escape”) key does on conventional keyboards. Prominently featured metaphors that made one want to make their programs use them.

Though I often wondered why there was not a corresponding key marked HURRY. Ought stopping a program without intermediate results be the only way to stop them? A lot of programming technology concerns itself with various ways to communicate stopping a program that's running, but always it's assumed that it has to give up on the idea of a graceful answer if you stop prematurely.

For example, there's a technique in graphics called interlacing where when sending a large image, the bits are sent in an order so that you can start to see the image early in fuzzy form and as more bits are received you can display it in crisper and crisper detail. It seemed to me that there might be occasions where you got tired of waiting for a download and pressed hurry to say “stop gracefully, the fuzzy image is fine.” This technique is perhaps not as relevant now that networks have gotten faster, but when first developed was quite important, and anyway I'm just offering it as a way to illustrate that there can be notions of partial results.

Or you might be doing a search and know that something has searched half of something and is waiting to the end to report results but you just want to see what's done so far, so again you could say HURRY and maybe get partial results instead of the full results.

If output is only to the screen, there's little difference between the abort and hurry concepts I'm describing, but if it's an API that returns a structural value, aborting usually means not returning a value, so having a way to interrupt in a way that caused the running program to return a well-structured partial result instead might create some different interaction styles. Here's a sketch in Python:

from collections import namedtuple

class HurryException(BaseException):
  """
  An exception that could be connected to
  a Hurry key interrupt, if we had such a thing.
  """
  pass
  
searchresult = namedtuple('searchresult', 'found,complete')
    
def hurryable_search(tester, collection_to_search):
  found = []
  complete = False
  try:
    for x in collection_to_search:
      if tester(x):
        found.append(x)
    complete = True
  except HurryException:
    pass  # Allow what may be a partial search
  return searchresult(found=found, complete=complete)
  
def hurry_up():
  try:
    raise HurryException()
  except Exception:
    # If there's no handler, then don't hurry after all.
    pass

Note that there are other possible implementations that, rather than raising an exception, might just dynamically adjust a parameter that controlled the degree of care taken on a search step. I'm not suggesting a specific strategy, just that such strategies exist.

And I could be wrong about the particular examples I've chosen being good ideas. Maybe they aren't the best illustrations. But I'm in a hurry to finish this essay and they were what I came up with in the time I alloted myself, before I told myself to just hurry up and go with what I had.

What I'm really trying to say is that I think the absence of a HURRY key on the keyboard means people mostly don't give a second thought to this question of whether programs should be possible to ask to “hurry up.” People just assume that if the key isn't there, the functionality is probably not needed from the keyboard. In effect, they assume the key is not there for a good reason. But maybe it's just an accident or a failure of imagination.

So, just to estate something I said already, but now that you have a bit more context: We spend a lot of time passively accepting that these metaphors we are offered, whether in terms of models of interaction or markings on a keyboard, are the right way to think about things. And we spend far too little time asking ourselves if they're the wrong metaphor or if some interesting metaphor has been omitted. Out of sight, out of mind, I guess.

It's a small point. But I figured if I said it out loud, you might end up passively accepting that it's something you really should think about.

 

---

Author's Notes:

If you got value from this post, please “Share” it.

The Suspend/Resume/Abort image is cropped from a photo I took of my own Lisp Machine's keyboard.

The HURRY image was generated at abacus.ai using Claude Sonnet 3.5 and FLUX 1.1 [pro] Ultra. Light post-processing was done with Gimp.