Our political pathology and its consequences

This is a post I’ve been sitting on for a couple years. The main reason being that the source I use, a YouTuber named Aaron Clarey, makes a prognosis for our society that I wasn’t too sure about, and I don’t like very much. I think we have enough evidence, though, that it’s accurate for the foreseeable future. So, I’m going ahead with it.

This is something I’d been trying to put my finger on for a long time. I feel as though the quality of our political dialogue has fallen off a cliff in the last 14 or so years. What I mean is it’s largely vacuous, cynical, and spiteful, and I can remember a time when it wasn’t like this. I’ve feared that this decline in our dialogue will lead to our society repeating the horrors that have occurred in authoritarian regimes, inside the United States, not necessarily in racial terms (though that could happen), but the same horrors nonetheless. I’ve seen some of the symptoms of this pathology, but I didn’t put the pieces together. The following videos, put together by Aaron Clarey in 2010, seem to paint a coherent picture of this. They cut a bit below the surface, to get at the inner lives of the people who influence our politics, and set government and corporate policies. It is just a hypothesis, but it matches with the symptoms I’ve seen. It is not a clinical study of these influencers. I nevertheless find it compelling.

The topic is on “crusaderism.” Clarey’s introduction was a bit disingenuous, because he said he was going to talk about the problem, “and what can be done about it.” As I get to below, he doesn’t really talk about what can be done about it. I mean, he ticks off some remedies that I strongly agree with, but you can tell his attitude is, “You can do this, but it’s likely going to be for naught. So, don’t bother.” There is reason to believe he was right about that.

He mostly covered the political Left, but he said a similar dynamic has been happening on the Right. His criticism of the Right seemed to match what I’ve seen with people who say they are conservatives, but who can’t justify their positions, or articulate anything about policy.

The short of Clarey’s hypothesis was that there are people who come from wealthy families, and are not willing to struggle, to get their hands dirty, to make a contribution to society. They go to college, get “easy A” degrees, and because they come to realize they can’t add anything of worth to society with what they’ve learned, through some sort of productive occupation, they feel the need to validate their ego. So they enter politics. They look for a cause. It doesn’t matter what it is, and they latch onto it like a dog with a bone. They advocate on behalf of the cause, but it’s really advocacy for themselves. They don’t care about the cause in the sense of trying to help society ameliorate a social or technical problem. The cause is a proxy for their life’s meaning. It’s not for something truly moral, where they’d care if their efforts resulted in some societal improvement. They don’t believe any of what they’re saying, in furtherance of their “cause.” The cause is meaningless. They advocate for it because being active in something that has an effect on society gives their life some meaning. They find purpose in having power over other people, and they use a guise of helpfulness as a shield against the pushback they get. Clarey said they find validation for their ego by being a destroyer of what other people have worked to build, because after all, it’s easier to destroy than create, and it’s affecting something beyond their home life. As I’ll get to later, I think this particular bit of analysis might skim over an underlying cause for “the destructive principle” that Clarey talked about.

His thesis is that this pathology has come to dominate our politics. One reason for this is the activity is well-funded. In some cases, their “causes” serve as paid jobs for them, funded by non-profits, and organizations like the United Nations. In the other cases, they’re “trust fund babies,” and create a “bonfire of their vanity,” using their own money, promoting their “cause.”

Before I continue, I feel it necessary to put a couple disclaimers here:

First, please excuse the typographical errors in Aaron’s presentation.

Second, I don’t agree with a couple of his assertions:

In Part 6, he talked about stats in useful vs. useless college degrees, and claimed that most undergraduates are getting useless degrees. He justified this with a chart, showing degrees in some categories, like arts and humanities vs. engineering. In the stats I’ve looked at, the useful degrees students have been getting outnumber the useless ones (though this may depend on what he and I consider “useful”), though I was looking at these stats several years after he made this. So, they may have changed.

In Part 7, he made a statement about “raising taxes to pay for increased spending.” I would strongly encourage people to look into the analysis that economist Art Laffer did on tax revenue as a percentage of GDP. The results are surprising, and worth looking at.

I looked up the Bob Geldof quote Clarey used in the third video, “We must do something, even if it doesn’t work,” because I was sure readers would find it so nonsensical that they would want to know if he really said it. I found the quote, attributed to Geldof, in a 2014 article, “How Charity Can be Selfish: Father Sirico on bad almsgiving.” from Forbes.com, though the wording is a bit different,

We need to do something, even if it doesn’t work or help.

It’s from a collection of short documentary films called “PovertyCure.”

The subject matter that Sirico and Jerry Bowyer talked about in the article, when discussing Geldof, sounds like it would relate to William Easterly’s book, “The Tyranny of Experts,” where Easterly describes the dysfunctional nature of our foreign aid efforts.

A note about Al Gore, since Clarey talked about him. Gore also “tried” with respect to the internet. He sponsored a bill in the late ’80s that ultimately led to the broadband version of the internet that we all eventually came to enjoy. A forward-looking move, though admittedly, he did not work on building the broadband internet. He did not manage the process of building it out, or of actually installing it. Other people at the NSF, various government agencies, and at universities around the country did that, several years before the internet was privatized.

In the segment below, Clarey made some connections between the obtaining of useless degrees and non-productive careers people enter, and the government policies that are enacted, which dampen economic activity. This results in declining wealth in society. Nevertheless, people try to live beyond their means, because they’re not willing to accept a decline in their standard of living. This results in increasing private and public debt. He also explained that this is why we see the rent-seeking that political interests have instituted in government policy. It’s a way of not producing value for society, but getting an income, anyway. This is why if a problem appears to be solved, these people find a new cause to champion. For they must have something to occupy themselves, and give their existence purpose. “The problem” can never really be solved. Otherwise, what would they do with their lives?

It could be easy to dismiss this part of his presentation, but I think if one looks at financial indicators on a societal level, his analysis stands up. There are some critical fiscal problems that are not being addressed at all. As this continues, there will be negative consequences to our economy. That is a sure thing. It’s just a matter of time.

Just a correction to what Clarey said at about 6:15 in the above video. He talked about average annual hours worked per capita, by country, and showed that in the U.S. we’d gone from about 2,000 down to “8,000.” What he meant was “about 1,800,” though by the chart he shows, I’d take it to between 1,700 and 1,800.

We are living a lie. I agree with Clarey that this lie cannot continue, but he said that even as our economic system collapses in the future, it’s unlikely that our society will acknowledge the lie. He talked about an economic model that I think is worth listening to and pondering, not in the sense of advocating for it, but understanding what’s really happening, called “the carrion economy.” Like scavengers, rather than producing wealth, we increasingly feed on the “carcass,” until there’s nothing left. This is not what we should want, but it’s what we as a society have been creating.

This next part got to some hard things to face: What do we do about this? He presented some things you can do, which he called, “The path of most resistance,” because if you do any of these things, you’re going to be swimming against the prevailing tide in our society. However, you can do these things knowing that you are at least promoting the well-being of the next generation. Whether the next generation ends up being better off than the previous one is another matter. These things cannot work to improve our standard of living in isolation.

The other hard part is facing the fact that the odds are against these efforts improving much of anything. So, he closed with what he recommended, which is “do nothing.” Don’t waste your time on a futile effort. Go Galt. He published a book called, “Enjoy The Decline,” where he talked about what’s coming, and what you can do to maximize your enjoyment of life while society grinds itself into the dirt. Of course, this sounds like a terribly immoral course of action. I am resistant to accepting it myself, but he considered it the most likely, and practical.

The reason being that the irony of history is that as a society grows wealthier, it creates this effect he described, in which the elite of society lose their virtue, because the social and economic conditions don’t demand that they maintain it in order for them to gain what they want. They don’t need to work to produce something of value, and so their motivations turn toward the useless, ignorant, and counter-productive. As a consequence of their lazy thought, they become resentful, and attack the very society that has given them all they have. I’ve heard this from multiple sources who are knowledgeable about history. In fact, one historian, Thomas West, reviewed the political theory the Founders had for the United States in his book, “The Political Theory of the American Founding.” He said that many of them pondered in their private writings, “What if our republic succeeds? What do we do then?”, because history had shown that too much wealth in a society leads to its downfall. This was one of their great unanswered questions. What they hoped for was that our society’s cultural institutions would keep us on the right track morally, maintaining our society’s essential character, but it was a vague hope. They really didn’t know what to do about it, since history provided no guidance, only repeated cycles of societal ascension and decline.

Many years ago, I sat through a presentation given by Mike Rosen, who presented a lot of evidence from government statistics, and he concluded the same thing as Clarey did: Our entitlement programs are unsustainable, and they are going to collapse, but not before they collapse our economy, because instead of making them sustainable, which would require some measures the majority of us are not going to like, we’re going to squeeze these programs, until the money runs out, but not before draconian economic measures are exhausted to maintain them. He gave the presentation not to give solutions that might give us hope, because in his view, we passed by our chances to do anything about this. His message instead was, “Prepare for the worst.” Rosen has a background in corporate finance, and I give his analysis credence. Indeed, the die is cast.

The decline is going to take time. We won’t likely see obvious signs of societal decay for a while, perhaps for many years, but as I’ve watched the political decisions our society has made in light of structural problems that I’ve seen unaddressed for decades, I’ve seen us be incapable of having some critical discussions, and making critical decisions, which must be had, and made, if we are to maintain and advance our society into the distant future.

We are a reactionary society. We only deal with crises when they arise, not before. That makes us freak out in the midst of crises, but it’s what we prefer. Arguing for addressing looming crises ahead of time doesn’t go anywhere, because too many people don’t want to focus on it. It doesn’t serve our short-term interests, and it’s too easily dismissed as alarmism promoted by demagogues who are seeking attention, and/or power. So, as I said above, there’s a strong argument for just preparing for the crap to hit the fan, because you can pretty well predict that’s what’s going to happen, no matter what you try to do to avert it.

Getting to a point I made at the beginning about Clarey’s analysis, Stephen Hicks gave a speech covering what Nietzsche saw as an envy dynamic that he predicted would arise in the future (from the perspective of someone in the 19th century). It gets to something that I don’t think Clarey explained that well: Why do our elite attack things that work well in our society, which promote the very things they say they support? Clarey just said that they attack big, obvious targets. Hicks said that there’s a deeper motivation: Envy, due to their sense of weakness. It fits with what Clarey said: They come to realize they can’t do anything that our society values. Yet, they have the expectation of power and prestige, to be someone whom people look up to. The fact that they don’t have anything society values makes them feel worthless. It gnaws at them, and hatred grows within them, because they feel entitled to be given a certain value in society. Nietzsche said, though, that they can’t live with themselves just hating their circumstances, and the society in which they live. They form their own morality that justifies their weakness. Secondly, because of their hatred of the society that does not value them, they attack its strengths, attempting to discredit its worth among as many as they can. As Clarey would say, they don’t care about society. It’s all about them, and their validation.

A YouTuber named Benjamin Boyce I think best summarized the mentality that Aaron Clarey talked about in his video, “Revenge of the Talentless.” He contrasted this with what developing a talent means. I like how he presented it, because it’s basic, true, and approachable; something for which those without a talent can aspire.

A couple of guys on YouTube, calling themselves A Dormant Dynasty, produced the video below, based on an article on “biological Leninism” by a different author, simply named “spandrell”. I’m including it here, because it adds another dimension to the discussion, of the political relationship between the elites that Clarey talked about, and the dependents who support them. A common trait that the elite class described here shares psychologically with the dependent class, in this analysis, is that the dependent class also feels that society does not value them. This elite approaches the dependent, and promises to give them their worth, so long as they grant them their loyalty. What transpires is that the dependent class feels that they only gain their value in society from this association. Without it, they feel worthless and powerless. This creates a powerful coalition structure that is united against the people who know that they have value to society; who seek to increase their standard of living by trading that value for a share of society’s wealth.

One thing I take exception to is these guys don’t always pick the best graphics for presenting their ideas. They have some cleverness, which keeps it entertaining, but at times I think they go over the line into cynicism that detracts from what they’re trying to get across. In this video, they use a graphic that uses the term “unfit” to describe the dependent class. I don’t agree with this terminology, as it makes them seem irredeemable. I’d rather think of them as “unpurposed.”

What I kind of like about the above video is that these guys take a long view with this analysis, that societies go through cycles of growth and decline (on one axis), and cycle through systems of social organization (on another axis), from the feudal, to the totalitarian, to the more liberal (not necessarily in that order).

This is a theory of the cycles of history, given by the same duo, which I think is worth contemplating, given what we are seeing. It’s a grim prognosis for the foreseeable future. I’m not fatalistic about this, but it may be something to prepare for, in whatever way you see fit.

This video covers some background before getting to that. I’ve skipped over most of it, to get to the point. If you want to see more of it, move the slider back to the beginning.

Related posts:

Psychic elephants and evolutionary psychology

Coming to grips with a frustrating truth

—Mark Miller, https://tekkie.wordpress.com

A starting point on virtual machines and architecture

Stack machines

Learning about stack machines is an adjustment for someone like myself, since I’m used to register machines. I tried my hand at it, reading the last chapter of, “Smalltalk-80: The Language and its Implementation,” to look at the description of, and the source code for the Smalltalk VM, and got lost pretty quickly.

I read articles on Stack machines, Burroughs large systems, and the Burroughs instruction set on Wikipedia. I think these are good backgrounders for what one needs to understand before digging into an implementation.

Trivia note: Four years ago, just for exploration, I tried my hand at learning the Forth programming language, reading “Starting Forth,” by Leo Brodie, and doing the exercises. If you know Forth, and look at the Burroughs instruction set, you will see similarities. Charles Moore got inspiration for creating Forth from the Burroughs systems.

I also found the following video helpful in organizing my thoughts on this subject. I was reading “Squeak: Open Personal Computing and Multimedia,” by Mark Guzdial and Kim Rose, and the chapters on the Squeak VM and its memory management got me asking some questions about the basic components of a VM. The title of the video below is “How to build a virtual machine,” but it’s really about “How to build a virtual stack machine.” The term “virtual machine” means a simulation of a computer architecture. In the video, Terrance Parr showed how to build a very simple virtual stack machine in Java. I like the scale of this example. It’s not threatening. If you have basic programming skills, you can do everything you see in this walk-through, and get a stack machine that works! He did not, however, demonstrate how to build a compiler, so you can write high-level source code for the stack machine, nor a garbage collector for memory management, nor a debugger, so you can step through the code, look at values interactively, and trace through the stack. 🙂 However, he demonstrated a trace function that you can use for primitive debugging.

He created some simple programs to execute in bytecode, by writing some extra code as part of the VM project. The set of bytecodes (just a set of numbers) are submitted to the virtual processor by making a function call. The result of each program (a single value) shows up on the virtual machine stack.

Parr’s presentation gets a bit disorganized when he talks about the call stack. Just have some patience. He clears it up towards the end.

Edit 6/22/2020: I realized once I tried following Terence’s presentation, to recreate his VM, that he didn’t clearly show all of his code. You can see most of the code he uses by pausing the video when he has parts of it shown in his IDE, but there’s some he doesn’t show at all, or he modifies it a lot. So, I’m going to paste in some code here to try to clear up the left out, and confusing spots.

He changed the cpu() routine a lot. So, I figured I would show how it ended up in the later part of this presentation, when he added stack tracing, and memory dump capability. Also, I’ve included the code he used for an important routine for tracing, called stackString().

void cpu()
{
   while(ip<code.length)
   {
      int opcode = code[ip];
      if(trace) System.err.printf("%-35s", disInstr());
      ip++;
      switch(opcode)
      {
      // case statements for bytecode operators
      }
      if(trace) System.err.println(stackString());
   }

   if(trace)
   {
      System.err.printf("%-35s", disassemble());
   }

   if(trace) System.err.println(stackString());
   if(trace) dumpDataMemory();
}

String stackString()
{
   StringBuilder buf = new StringBuilder();
   buf.append("stack=[");
   for(int i = 0;i <= sp; i++)
   {
      int o = stack[i];
      buf.append(" ");
      buf.append(o);
   }
   buf.append(" ]");
   return buf.toString();
}

In the third phase of his presentation, when he showed how to compute Fibonacci numbers with this VM, he didn’t show some bytecode operators that are necessary for making the Fibonacci program work. I’m showing the code here for those bytecodes, which I wrote myself. I must admit, I have not tested this code in Java, as I translated Terence’s code into a different language to try it out. If this doesn’t work, I apologize in advance. I can say the logic is sound. So, any errors this code generates just requires a little debugging on my misunderstanding of how Java specifies things.

These case statements go inside the switch statement in the cpu() function. Note that Terence created a couple enumerations, TRUE and FALSE, which hold the values 1 and 0, respectively, which you should include in your code, as well:

case ILT:
   int val1 = stack[sp—];
   int val2 = stack[sp—];
   if (val2 < val1)
   {
      stack[++sp] = TRUE;
   }
   else
   {
      stack[++sp] = FALSE;
   }
   break;
case ISUB:
   val1 = stack[sp—];
   val2 = stack[sp—];
   stack[++sp] = val2 - val1;
   break;
case IMUL:
   val1 = stack[sp—];
   val2 = stack[sp—];
   stack[++sp] = val2 * val1;
   break;

You may or may not notice this, but in the rush of assembling the code for his presentation, he ended up duplicating code in disInstr() and disassemble() (he shows the code for both). When he’s through putting everything together, these functions end up with the exact same code in them, though his code calls both of them. Of course, under normal circumstances, he would’ve just used a single function to disassemble the bytecodes.

To get some ideas for “where to go from here,” I liked reading How to build a simple stack machine, by Nicola Malizia. Though Nicola’s English is wobbly, what I like is that he sketches out some basic logic for implementing control structures, variables, and procedures in a way that’s mostly compatible with the machine model that Terence laid out. An element he adds is labels for branching, so we can have mnemonics for addresses, instead of just numbers. Nicola defined a language for doing all of this.

Where he departs from Terence’s model is he implements what I’d call an interpreter, not a VM, but these distinctions get blurry. He doesn’t create an assembler for his machine. So, he has no bytecodes to execute. In Nicola’s scheme, the instruction pointer literally points to an array of instruction strings that are parsed, as the program executes. However, he implements a stack, with stack frames.

Getting acquainted with the concept of architecture

In my learning process, I’ve liked working with a low-scale (8-bit) architecture from my youth (in an emulator), based on the 6502 processor. It’s kept things more comfortable, as I’m getting used to ideas about using computing for modeling. I really enjoyed the presentation below, by David Holz, which is about a 16-bit VM that runs on another vintage 8-bit computer, the Commodore 64. The C-64 uses a 6510 processor, a very close relative to the 6502. This 16-bit VM is called ArcheronVM.

If you’re not already familiar with it, you’ll probably want to learn some 6502 assembly language, to understand what Holz talked about, since his scheme uses 6502 code as a kind of microcode for the 16-bit virtual processor. 6502 assembly is a simple CISC instruction set (compared to today’s processors).

What I particularly like is his presentation gets across a basic idea in something Alan Kay told me about many years ago, when I first started corresponding with him:

[T]o me, most of programming is really architectural design (and most of what is wrong with programming today is that it is not at all about architectural design but just about tinkering a few effectors to add on to an already disastrous mess).

What I used to understand about the term “architectural design” had to do with designing data structures and APIs (perhaps abstract data types), but that’s not really what Kay was talking about. I had some experience with it by going through the third chapter in SICP, seeing what’s possible with computing mathematical series using lazy evaluation (I wrote about a few exercises in that chapter, at SICP: Chapter 3 and exercises 3.59, 3.60, and 3.62). What comes through in Holz’s presentation is the importance (and power) of architecture in the design of a VM.

A few years back, I read about the Lisp Machines K-Machine, a computer that Lisp Machines, Inc. never released. The linked article talks about a design feature that Holz also used in his architecture, called “tag bits.” It’s a method of encoding meta-information about an instruction, or an address. It was also used in the Burroughs machines.

 

I’ve been interested in this topic for years, because I had a “2×4 across the head” experience while I was working in IT services in the mid-90s. I was working on a software project that was part of an in-house data-driven application platform. It was an interpreter that implemented a page description language, which also allowed some “scripting.” It was used for generating reports. I did a lot of wrestling with it, since it ran on MS-DOS, and was written in C. The combination of these was an awful experience. At the time, it inspired me to think about how to make the interpreter’s architecture better (because I didn’t know any other approach was possible). I’m using “architecture,” in the old sense of how I thought about it. The approach I used ended up being like trying to graft onto/augment a badly designed machine. In hindsight, what I was really trying to improve upon was the combination of running C on MS-DOS, without modifying the architecture offered by either. My effort produced some improvement, but the code was a lot of make-work. In hindsight, what I came up with was the kind of coding scheme that justified the use of meta-languages with code generators in the 2000s, as it became very repetitive. What I’d say is when you see that pattern developing, it might actually be a signal that you need to improve the architecture you’re using (here, I’m using the term in the new sense), because what you’re really doing is compensating for a systemic weakness, exemplified by the operating system and/or the programming language you’re using. I had no idea how to do that. It wasn’t part of the curriculum in my computer science education, which I regret.

As a commenter to Terrence Par’s video said, “It’s too bad that this isn’t part of a software engineer’s education anymore.” The commenter mentioned a couple examples of where this design method was used to good effect in commercial software in the 1980s, and mentioned Don Knuth’s book, “The Art of Computer Programming,” which uses a VM, called MMIX.

Though, I can’t help reflecting on something else Kay said back in the ’70s, “People who are really serious about software should make their own hardware.” For me, that’s going to have to wait for another day.