Being abstract is something profoundly different from being vague … The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise. - E.W. Dijkstra
I think any objective observer would conclude we have a political malaise in the US, and possibly, worldwide. Depending on who you talk to, this is maybe caused by social media, capitalism, russia, boomers, millenials, racism, fox news, the death of expertise, and so on.
But separately to any of these causes, I think we suffer from a second-order issue, namely a poor political "typesystem". This concern is not getting nearly (or, any) weight, and I think this is a mistake.
Programmers intuitively understand that we can't write code for every case. You don't rewrite the
The nature of these tools has varied over time, along with the specific constraints and concerns in that era. At one time, there was a great debate over compiled and interpreted machine models, before JITs threw a wrench in our two-party system. For a minute, OO and its various patterns were dominant, before we started mixing in more patterns from the functionalists and considering alternatives to inheritance. For awhile, dynamic typing provided the most expressive polymorphic abstractions (at some cost of speed/correctness), before static typing caught up with modern features like protocols/traits, generics, constraints, and inference. Right now, languages like Rust are statements that static abstractions can be both safe and fast, at the cost of some productivity.
The details of how and whether, e.g., generics are really competitive with runtime casting is not my point. Rather, I mean that programmers have conversations about those kinds of details, and not about the details of "how to write a function to buy a plane ticket". The closest you will get to "plane ticket code" in a programming blog is the plane ticket as a specific example of a general pattern. Plane tickets might be the contents of an array, or they might conform to a
Buyable protocol, or we create nodes for them in the DOM tree or a table for them in the database, views that display them in UIKit, etc. But we work and think, pretty much entirely at a level of abstraction above the plane ticket, if not several levels above.
In politics, however, all the discussions are "about the plane tickets". Even things that are supposedly abstractions like "pro-life" tend to have very limited applicability to any context this is not the obvious context you know is the one I'm talking about. Every situation is a specific situation, about which no higher principles or conclusions are to be drawn. And as any assembly programmer can tell you, writing separate code for each situation can be great fun, but it can also be quite tedious and error-prone. "Tedious and error-prone" is, I think, a very accurate description of our current political situation.
I saw this thread recently on Hacker News:
Call me a corporatist, but I don't even think Google and Apple should have to justify their 30% pricing at all as "reasonable". They could charge anything they like -- 100%. It's a voluntary contract, and Epic doesn't have to engage in it. We don't have to engage in it. There's no fundamental right to offer an app on an app store, and if the scope of the market is defined as the market for video games/content, then none of these places are monopolies and companies/people are free to set their desired prices.
This encapsulates an argument I've heard pretty often against app store regulation. However, one user instantiates the argument over different types:
Call me a democrat but I think the United States of America shouldn't have to justify its laws at all and should regulate Google's and Apple's store however they want, tax them 100% instead of 20%, after all they voluntarily made a business, they can move their HQ to Swaziland, who is to tell the American people how to regulate their businesses
It's not like Apple and Google can't move, there's like 200 countries, that's like a hundred times more countries than app stores
The implicit criticism here is that when we apply the argument to a new situation, we get unexpected results. I think many of us have dealt with bugs like this in programming. Certainly, sometimes the way to resolve them is to constrain the input to an expected range, even if we need to write more functions for other situations. Other times, the solution is to rethink our abstraction to get a common framework that can cover everything.
The point is, we're not really in the habit of doing either of those things politically. We don't introduce our argument with "Given a corporation of a certain size..." "Given an entity that people interact with 'voluntarily' with regard to conditions
V...". We just write a new argument to defend a position for each situation. If there's a new situation, we need a new argument every time, and please don't hold me to the argument I made the last time, it's different now.
Nowhere is this more evident than in the current fight over the Supreme Court. In 2016, Senate Republicans blocked Garland's nomination "because it was in an election year", and in spite of arguing very forcefully that this was some kind of principle that should be followed, now that it's their nominee they're quick to abandon it.
As far as I'm aware, that's about as far into the abstraction as anyone bothers to think. However I'd like to make two even higher observations. The first is that the real "principle" in play appears to be some version of "elections have consequences", which, abstracting the types a bit more, becomes a sort of "might makes right". I think many people would disagree with "might makes right" as a general principle, but because of our habit of having each political thought separately this connection is not necessarily clear when we advocate for a particular instantiation of it.
A similar argument that arises in many areas of hacker politics is that we ought to view some conduct a certain way, because it does (or does not) "violate the law", "violate the terms of the GPL", or whatever document seems like it advances our interest. This, of course, ignores the idea that our feelings are not bound by law nor license terms. More relevant to the political context, this sort of reasoning bypasses any discussion of what the law should be, which is the question in a democratic society, and replaces it with an acknowledgment that so-and-so came to power and here's what the law is, which is a weaker form of might-makes-right advocacy.
'Might makes right' as a political theory has many unintended consequences. One of them is the oft-observed erosion of our political norms. In response to a hypocritical nomination, the left has discussed retaliatory options such as court-packing or term limits, and the right uses the threat of that to push through the nomination now. It seems we are hopelessly locked into a political system that serves to polarize society and prevent government from operating and addressing current crises at any level. But more directly to our current news cycle, if 51 votes is cause for celebration among conservatives, it would follow that losing a few – say, because some of them got COVID – might be a celebration for Democrats. Whatever examples of the latter one might dig up is currently getting wall-to-wall coverage in conservative media. Of course, it's presented as if it exists in a vacuum, totally unconnected to last week's Republican strategy.
Another observation is that abstract principles themselves are becoming politicized. Democratic leadership is responsive to criticisms over abstract principles in way that Republican leadership is not. Biden pulled down his attack ads four years to the day that Trump attacked his opponent's health personally. One could argue that both of these are simply political strategies designed to appeal to a base. But if so, it suggests that what appeals to each base is very different.
In spite of the weak embrace of metapolitical reasoning by one party, which we might naturally expect to alienate the other party, I think metapolitics is our best, and perhaps only way out of this mess.
Some of this will be immediately apparent to the programmer. But metapolitical reasoning allows us to solve a problem once and re-use our solution many times. Software scales to the world's problems only because of our ability to encapsulate plane tickets and purchases and so on into objects or type instances, against which we can generically develop datastructures and algorithms without specializing them by hand for each case. Politics exists in a similar problem domain of "running the world", and it faces similar challenges, and we will not be able to meet them by always writing new political argument for each case.
As a separate issue, working at higher levels of abstraction gives us rhetorical distance and some protection against bias. It's very easy in the context of a specific political issue to write the rules to come out a certain way. Working generically forces us to consider alternative perspectives, and the limitations of our solution within a broader political framework.
So what does this look like? For one thing, we need better names.
In computer science, we have a robust vocabulary of abstractions. We know the flywheel pattern, RAII, inheritance, protocol-oriented, generics, and so on. Some of these have slightly different meanings in different programming communities but there is a broad tapestry of language to discuss such topics. This is of course, entirely besides the fact that we have formal languages to examine abstraction in particular programs.
In rhetoric, we have one pantheon like this in form of logical fallacies. You can see a long list of them on Wikipedia. These fill a similar role, in that we make some attempt to cover them academically and they are an abstraction free from any particular argument for or against a particular policy.
What we aren't doing is keeping them up to date. Occasionally, someone will produce a new one – the rationlists have the "motte and bailey" for example – but it's pretty rare and even then, it doesn't really penetrate politics at all. Moreover, there are many "devices" that are not fallacies per se, but are sort of "tools to have a new thought".
The "instantiate the app store argument with unexpected types" seems like it ought to be a general device with a catchy name. To apply it to some other examples, if we believe democracy is a fair system of electing a country's leaders, what does it say about choosing a company's CEO? If we ought to adopt animals from shelters instead of from breeders, what does it say about making new children? If Net Neutrality is good regulation against ISPs, what does it say about regulation against YouTube? There seems to be plenty of "new" political landscape to explore if we have the device to pose the question.
Another device is to consider how to apply a principle "against" its current motivation. Obviously in the Merrick Garland case, Senate Republicans did not expect to be in the situation of having their own election-year nominee. Similarly, Republicans did not consider abortion rights as a potential side effect of religious freedom. Of course, this occurs in part because our democracy lacks a method to enforce this sort of ideological consistency.
But, we could create one. We already have rules that congress can't raise their own pay, or criminalize behavior retroactively. We could require rules to take effect in a way that advantages the other party first. We could adopt the social principle that proposals ought to be made by those who can be disadvantaged by it, and not those who are mostly advantaged. Such a politics would be very different than our own, and may have new problems but at this point I think "very different" is a feature.
Really though, I think we ought to be designing and naming these sorts of higher-order patterns, recognizing them in political discussion and instantiating them into workable abstractions. Such discussion ought to be the dominant form of political discourse, not "what dumb thing Trump did this week", in a similar way that type theory and design patterns are dominant themes in the programmer discourse, not "what dumb plane ticket function I wrote this week".