A Nerdly, Software-Engineering-ish, Computer-Sciencey Approach to the Gay Marriage Debate

Gay marriage is a proposed change that’s hoped to be an optimization. Advocates say that the current system (society) is sub-optimal in that a particular sub-system (marriage) is not sufficiently general (same-sex couples aren’t allowed to participate). Let’s say marriage is a function by which a man and a woman are combined to create an object conforming to the Family interface:

marriage(Man,Woman) : Family

The proposed optimization generalizes this function:

marriage(Person,Person) : Family

A general rule in software engineering is to maximize the generality of the input parameters (Person instead of Man or Woman). In this light, the second marriage function represents an improvement because it makes the marriage function applicable to more people.

However, this focus on the function signature obscures some important issues. For one thing, the marriage function does not stand in isolation, but is embedded at the core of an extremely complex network of functions. In software this is known as the call graph. For example, the network of function calls in one relatively small piece of software looks like this:

seL4 microkernel call graph

Each node (circle) represents a function, and each edge (line between circles) represents one function calling (using) another. Now imagine the complexity of such a graph for our entire society, in which marriage constitutes only a single (though essential) node, connected to things like employment relationships, governmental functions, child-rearing, religious organizations, and so on. A key function like marriage would be at the center of the graph, like the large green dot in the middle of the picture. Messing with that node can affect not only it and its immediate neighbors, but actually every other node in the graph.

It should also be noted that the proposed optimization not only redefines the function signature (who can participate in marriage) but actually provides a new implementation for the function:h

class GayFamily implements Family {
// a bunch of experimental code...
}

In software, the new implementing class could be automatically tested to make sure it meets the requirements of the Family interface. In society, such automated tests are unavailable, and the impacts of this new implementation may not be fully known within the natural lifetime of anyone now living.

In fact, it’s essentially impossible to conduct the sort of experiment needed to assess whether gay marriage is a good idea. We’re not just interested in effects on individuals or families (important as they are) but on entire societies. It would require many societies under many circumstances randomly assigned to either implement or not implement the change, and for sufficient time to pass for the network effects to work themselves out.

Obviously this line of reasoning could be applied to various types of radical social change, and I’m certainly not saying that such change is never justified. But I am saying we need humility and caution when hacking a key function like marriage that the entire system is built around. In the end, this isn’t software. This is society. It’s parents, it’s children, it’s lives.

Because an robust empirical evaluation of this change at the civilizational level will not be soon forthcoming, anyone with an opinion must come to it by non-empirical means. And my opinion is that this change isn’t worth the risk.

Leave a Reply

Your email address will not be published. Required fields are marked *

Connect with Facebook