Applied computing is fundamentally a problem of languages, both natural and artificial. At least five languages mediate every interaction that we have with computers: first, the machine instruction sets, which are a prerequisite for all stored-program computing; second, the higher-level programming languages, which allow us to direct computation at a conceptual level; third, the algorithms, data structures, and “ontologies,” which give processes and objects of the world their computational representation; fourth, the visual and gestural languages of user interfaces, which open up computing to non-specialists; and fifth, the innovations in natural language that we humans need in order to talk to each other about machines with unprecedented capabilities and behaviors.
The first two levels of language are largely the domain of specialists, despite some progress in the development of very high-level programming languages. Nonetheless, the functioning of these languages has a significant impact on the life and work of non-specialists. While these languages are “universal” from a theoretical point of view—in the sense that each of them can equivalently express anything that can be computed—this is not so in practice: if a problem is difficult to express using the formalisms of a particular language, then it will be difficult to solve. In addition, the actual temporal and spatial performance of computing depends on implementation at both the hardware and software level. Hence, numerous instructions sets, and general-purpose and domain-specific languages have been invented since the beginning of computing.
Even at a theoretical level, the last three levels of language are quite particular and contingent, and they are of concern to everyone who uses computers. If the computational representation of a real-world object is too reductive, computing will not yield satisfying results. If it is too detailed, the representation will be as complex as the object itself. If a user interface is ill-suited to the contingencies of practice, it can prevent adoption of an otherwise sound computing system. Finally, even if all of the foregoing are attended to, if computing introduces novel concepts or ways of working, the application of these concepts depends on the development of suitable language to explain them.
Because of this, the practical application of computing varies widely from field to field, depending in large measure on how well the system of languages works. The field of architecture casts this problem into high relief because, as we shall see, applying computing to visual and spatial problems is particularly difficult, and architecture’s non-computational linguistic systems are highly developed, expressive, and flexible, and central to the profession’s identity.
The question of how architectural computing should work—and what it means for the profession’s future—is now especially urgent. From the 1980s until the early 2000s, architecture as a whole regarded computing with skepticism. Apart from a small number of avant-garde or technologically progressive firms and a dispersed community of enthusiasts, architects adopted only those modes of computing that fit into existing modes of practice. The existing languages of architecture remained largely intact.
Meanwhile, computing developed at an astonishing pace in other fields. About ten years ago it became clear that architecture could no longer ignore these developments, and the profession has since rallied under the banner of “Building Information Modeling” or BIM, even if there is still little agreement on what this means. Aspirations are high, but decades of ambivalence towards computing cannot be overcome quickly.
Too often, the present problem is understood as a problem of tools instead of a problem of languages. This obscures the hard work that must be done by all of us in architecture: the development of a tool is the responsibility of its maker, but the development of a language is the collective responsibility of all of its speakers. Accordingly, architecture cannot hope to find its way forward without developing a new system of languages that is integrated with modern computing. This system must be as expressive, flexible, and mutually intelligible as the old system of architectural representation and discourse.
In the posts to follow, we will explore all five levels of this problem. To be continued….