This post summarises computational legalism, a concept I developed in my doctoral thesis that is borne of the parallel between code’s ruleishness – its reliance on strict, binary logic instead of interpretable standards – and its conceptual equivalent in the legal realm, known as legalism (more specifically the strong variant of the latter). Strong legalism is an ideological perspective that shuns the holistic interpretation of legal norms, instead requiring that citizens merely follow legal rules as they are presented to them, without enquiring as to their efficacy or their legitimacy beyond the question of whether they were declared and published by an authorised institution.

Code’s characteristics demonstrate a particularly strong form of legalism. As Bańkowski and Schafer put it, ‘[t]he alternative to legality is not anarchism, it is legalism… “not thinking about it”, if left to its own devices, tends to take over the entire social world, or at least cyberspace’ (Bańkowski and Schafer 2007). Therein lies the problem of code-based regulation and the claim that code is ‘less’ than law, i.e. it does not demonstrate the characteristics of ‘legality’ that make traditional laws legitimate exercises of power. An immediate objection to this claim is of course that code is not law, and therefore the question of its legality is moot. This is to miss the point, however. If code regulates our behaviour, and mediates our legal practices (Diver 2018), then we have to ask what standards for its design might render its doing so legitimate. Whereas orthodox legislation is legitimated by democratic processes, it is not at all clear that such an aspiration is reflected in the production of code. Citizens’ behaviour is moulded by the private commercially-driven norms of the online space, with such effects usually being imposed outside of either democratic debate or legal processes of interpretation, contest, and remediation (this imposition is the ‘normative shortcut’ I referred to in a previous blog post).

With that in mind, however, my purpose is not to suggest that the designers of code harbour a legalistic ideology, but rather to suggest that certain characteristics of strong legalism are reproduced in the ontological character of code: the ideological ought of strong legalism very easily becomes the technological is of code.

The rest of this post briefly summarises legalism before setting out the characteristics of code that make it so legalistic. The resulting notion of computational legalism provides us with a theory of code that is open to various kinds of existing legal-theoretical responses traditionally intended to minimise or avoid legalism in the jural domain.

What is legalism?

In the legal context the rote application of rules is undesirable, at least in a society built around the ideals of democracy and legality. The particular conception of legalism that is reflected in code’s character is closely connected with stronger, more ideological forms of analytical legal positivism, according to which rules and the strict adherence to them are the proper fundaments of social ordering. That the state defines what is legal is sufficient to legitimise the positive norms it chooses to declare; in constituting the field of play (the legal system), the state legitimises de facto those norms which it consequently promulgates as the rules of the game (i.e. positive law). Constitutive facts (natural laws, the social contract/constitution, or a mix of these) operate prospectively to legitimise any subsequent act of the sovereign (Wintgens 2012). The citizen is required to act unthinkingly – the rules are ‘just there’, and she need only act in accordance with them as written (Bańkowski 1993), since by virtue of natural law/the social contract the pronouncements of the sovereign are ‘imputed to [the people], as if they were its author’ (Wintgens 2012).

This legalistic outlook therefore tends towards a ‘narrow governance of rules, unleavened by the principled approach to interpretation’ (Bańkowski and MacCormick 2000). The apparent simplicity of this form of governance implies the risk of abuse: the prioritisation of rule-following militates against citizens’ critical reflection and the application of other principles that we might want to be reflected in a democracy, such as legality. The absence of such levelling forces can lead to legal rules becoming ‘implements of tyranny’ (ibid.).

Computational legalism

From this very brief summary of legalism one can begin to appreciate how code can exemplify these characteristics (Bańkowski and Schafer 2007). Even in the most tyrannical state there is space to interpret, and even to disobey – the hermeneutic gap between the text of a norm on the page and its translation into behaviour in the world or its enforcement by a court makes this at least a notional possibility (Diver 2018).

In the environments where code is designed, however, the elision of that gap is not only easy to do but is entirely standard, not necessarily through malice or intentional obfuscation (although they are certainly a problem), but simply by virtue of the ontological characteristics of code, which by nature presents rules or norms to the individual that ‘just are’. Even where the code does allow for choice via adjustable settings, the default configurations of code tend to be seen by individuals as ‘a natural and immutable fact’ (Kesan and Shah 2006). The hermeneutic gap is thus closed, or at least significantly narrowed, because the ‘text’ of the ‘rule’ (the source code) constitutes directly the geography of the artefact: they are not just isomorphically related, they are one and the same. Unlike traditional law, whose ‘carrier’ has hitherto been the inherently passive medium of text, software code allows us to, as Latour (1992) puts it, ‘conceive of a text (a programming language) that is at once words and actions’. What we have with code, then, is potentially the apex of legalism: the normative collapses into the descriptive (what was once requested becomes simply what is or shall be), and there is no choice but to obey the rule as it is formulated by the designer, much less to view and contest it, since it constitutes empirical reality predetermined from the outset (Hildebrandt 2008).

The elements of computational legalism

While code’s ruleishness is a central characteristic of computational legalism, there are several additional characteristics that take it beyond even the strong legalism envisioned within the jural domain. The opacity of code makes its regulative operation inscrutable to the end-user. This is true in the course of the code’s execution, but also in relation to the provenance of the code and, by extension, its very purpose. These effects are compounded by code’s immediacy, or the speed with which it imposes the particular configurations of (opaque) normativity that it embodies. Add to these code’s immutability (the tendency, either for technical or economic reasons, for specific codebases to settle in an artefact) and its pervasiveness (one piece of code regulating innumerable individuals via the same product, multiple artefacts regulating one individual in the course of her connected life, or a combination of the two). Factoring in code’s private production, all of this contributes to the problematic assemblage of normative effects that mean in many cases that code is simultaneously more powerful and less adaptable than a law-system that is built around the characteristics of delay, flexible interpretation, and ex post remediation.

Computational legalism thus tends towards a combination of brittleness, normative force, and lack of ex post control that is far in excess of even the most strongly-legalistic of traditional legal systems. Between the instrumentality of code and its legalistic imposition of normativity, it can thus be said simultaneously to be more, and less, than law (Diver 2018).


We have seen how the characteristics of code come together to demonstrate a form of legalism that is significantly stronger than that envisaged in the legal domain. With code we have the apex of legalism: from the individual’s perspective, code’s architectures are ‘just there’, while simultaneously its constitutive nature defines what practices are possible, by definition ruling out all the possible alternatives that the plasticity of the code might otherwise have allowed for. Code does not just represent reality, as legal rules do under strong legalism (Wintgens 2012), but actively constitutes it. The behaviour of the individual is to a great extent bound ex ante, and since she will in most cases not be aware of that binding she is, through no oversight or mistake on her part, forced to acquiesce blindly to the rules that are inscribed in the code (Hildebrandt 2008): she is deprived of even the possibility of choosing whether or not to ‘think about it’ (Bańkowski 1993).

These problems are compounded by the speed of execution, the veiling of commercial design decisions by technical opacity and intellectual property law, and the need for the designer consciously to counter them in the process of design (something that may conflict with her commercial incentives).

Computational legalism and COHUBICOL

From the perspective of COHUBICOL, computational legalism is problematic in its sidelining of legal processes that keep in check the exercise of power over the citizens of democratic polities. Traditional (text-based) laws that demonstrate (strong) legalism are apt to be dismissed as non-law (Fuller 1977), and with text-driven normativity we can rely on the hermeneutic gap to give us time to think about whether or not that is the case. Data- and code-driven law, on the other hand, may have significant consequences for law-as-we-know-it if they, and the systems that embody and enforce them, are not consciously designed to avoid the characteristics of computational legalism.

(For a more detailed discussion of computational legalism, see Diver (forthcoming) and chapter 3 of Diver (2019)).

Selected references

  • Bańkowski Z., ‘Don’t Think About It: Legalism and Legality’ in M.M. Karlsson, Ó. Páll Jónsson and E.M. Brynjarsdóttir (eds.), Rechtstheorie: Zeitschrift für Logik, Methodenlehre, Kybernetik und Soziologie des Rechts (Berlin: Duncker & Humblot, 1993)
  • Bańkowski Z. and N. MacCormick, ‘Legality without Legalism’ in W. Krawietz et al. (eds.), The Reasonable as Rational? On Legal Argumentation and Justification; Festschrift for Aulis Aarnio (Berlin: Duncker & Humblot, 2000)
  • Bańkowski Z. and B. Schafer, ‘Double-Click Justice: Legalism in the Computer Age’ (2007) 1 Legisprudence 31
  • Diver L.E., ‘Digisprudence: The Affordance of Legitimacy in Code-as-Law’. Ph.D. thesis, University of Edinburgh, 2019 (
  • Diver L. ‘Digisprudence: The Design of Legitimate Code’ 13(2) Law, Innovation and Technology (forthcoming in 2021) (
  • Diver L., ‘Law as a User: Design, Affordance, and the Technological Mediation of Norms’ (2018) 15 SCRIPTed 4
  • Fuller L.L., The Morality of Law (Yale University Press, 1977)
  • Hildebrandt M., ‘Legal and Technological Normativity: More (and Less) than Twin Sisters’ (2008) 12 Techné: Research in Philosophy and Technology 169
  • Latour B., ‘Where Are the Missing Masses? The Sociology of a Few Mundane Artifacts’ in W.E. Bijker and J. Law (eds.), Shaping Technology/Building Society: Studies in Sociotechnical Change (MIT Press, 1992)
  • Wintgens L., Legisprudence: A New Theoretical Approach to Legislation (Oxford: Hart, 2002)
  • Wintgens L., Legisprudence: Practical Reason in Legislation (Surrey: Routledge, 2012)