In cases of simple translation (where there are no latent ambiguities and our tradition seems to speak clearly), judges should firmly advance arguments that seek to preserve original values of liberty in a new context. In these cases there is an important space for activism. Judges should identify our values and defend them, not necessarily because these values are right, but because if we ignore them, we should do so only because they have been rejected — not by a court but by the people.
In cases where translation is not so simple (cases that have latent ambiguities), judges, especially lower court judges, have a different role. In these cases, judges should kvetch. They should talk about the questions these changes raise, and they should identify the competing values at stake. Even if the decision they must adopt in a particular case is deferential or passive, it should be deferential in protest. These cases may well be a place for prudence, but to justify their passivity and compensate for allowing rights claims to fail, judges should raise before the legal culture the conflict presented by them. Hard cases need not make bad law, but neither should they be treated as if they are easy.
That is the simplest response to the problem of latent ambiguity. But it is incomplete. It forces us to confront questions of constitutional value and to choose. A better solution would help resolve these questions. While it will never be the job of the courts to make final choices on questions of value, by raising these questions the courts may inspire others to decide them.
This is the idea behind the doctrine of a second look outlined twenty years ago by Guido Calabresi, a professor at the time who is now a judge.[2] Brutally simplified, the idea is this: When the Supreme Court confronts issues that present open, yet fundamental questions of value, it should be open about the conflict and acknowledge that it is not plainly resolved by the Constitution. But the Court should nonetheless proceed to resolve it in the way most likely to induce democratic review of the resolution. If the resolution induces the proper review, the Court should let stand the results of that review. The most the Court should do in such cases is ensure that democracy has its say; its job is not to substitute its values for the views of democrats.
Many ridicule this solution.[3] Many argue that the framers clearly had nothing like this in mind when they established a Supreme Court and permitted judicial review. Of course they did not have this in mind. The doctrine of a second look is not designed for the problems the framers had in mind. As a response to the problems of latent ambiguities, it itself reveals a latent ambiguity.
We might deny this ambiguity. We might argue that the framers envisioned that the Court would do nothing at all about latent ambiguities; that in such contexts the democratic process, through Article V, would step in to correct a misapplication or to respond to a changed circumstance. That may well have been their view. But I don’t think this intent is clear enough to foreclose our consideration of how we might best confront the coming series of questions on the application of constitutional value to cyberspace. I would rather err on the side of harmless activism than on the side of debilitating passivity. It is a tiny role for courts to play in the much larger conversation we need to have — but to date have not started.
Responses for Code
A second challenge is confronting the law in code — resolving, that is, just how we think about the regulatory power of code. Here are a number of ideas that together would push us toward a world where regulation imposed through code would have to satisfy constitutional norms.
Here again is the link to open code. In Chapter 8, when I described a kind of check that open code would impose on government regulation, I argued that it was harder for government to hide its regulations in open code, and easier for adopters to disable any regulations the government imposed. The movement from closed to open code was a movement from regulable to less regulable. Unless you are simply committed to disabling government’s power, this change cannot be unambiguously good.
But there are two parts to the constraint that open code might impose; one is certainly good, and the other is not necessarily terrible. The first part is transparency — the regulations would be known. The second part is resistance — that known regulations could be more easily resisted. The second part need not follow from the first, and it need not be debilitating. It may be easier to disable the regulations of code if the code is in the open. But if the regulation is legitimate, the state can require that it not be disabled. If it wants, it can punish those who disobey.
Compare the regulation of seatbelts. For a time the federal government required that new cars have automatic seatbelts. This was the regulation of code — the car would be made safer by regulating the code to force people to use seatbelts. Many people hated seatbelts, and some disabled them. But the virtue of the automatic seatbelt was that its regulation was transparent. No one doubted who was responsible for the rule the seatbelt imposed. If the state didn’t like it when people disabled their seatbelts, it was free to pass laws to punish them. In the end the government did not press the issue — not because it couldn’t, but because the political costs would have been too high. Politics checked the government’s regulation, just as it should.
This is the most we can expect of the regulation of code in cyberspace. There is a trade-off between transparency and effectiveness. Code regulation in the context of open code is more transparent but also less binding. Government’s power to achieve regulatory ends would be constrained by open code.
There is another benefit. Closed code would make it easier for the government to hide its regulation and thus achieve an illicit regulatory end. Thus, there is no simple defeat of government’s ends but instead a trade-off — between publicity and power, between the rules’ transparency and people’s obedience. It is an important check on government power to say that the only rules it should impose are those that would be obeyed if imposed transparently.
Does this mean that we should push for open rather than closed code? Does it mean that we should ban closed code?
No. It does not follow from these observations that we should ban closed code or that we must have a world with only open code. But they do point to the values we should insist on for any code that regulates. If code is a lawmaker, then it should embrace the values of a particular kind of lawmaking.
The core of these values is transparency. What a code regulation does should be at least as apparent as what a legal regulation does. Open code would provide that transparency — not for everyone (not everyone reads code), and not perfectly (badly written code hides its functions well), but more completely than closed code would.
Some closed code could provide this transparency. If code were more modular — if a code writer simply pulled parts off the shelf to plug into her system, as if she were buying spark plugs for a car — then even if the code for these components was closed, the functions and regulation of the end product would be open.[4] Componentized architecture could be as transparent as an open code architecture, and transparency could thus be achieved without opening the code.
2.
Guido Calabresi,
3.
Or come close to doing so; see Richard A. Posner,
4.
I am grateful to Viktor Mayer-Schoenberger for demonstrating this point to me. Hal Abelson points out that the components would have to be verifiable if they were not themselves open. Otherwise, components could function as Trojan Horses — pretending to be one thing while in reality being something else.