Composability, homogeneity, and language-based systems
Composability, homogeneity, and language-based systems
I’d like to describe and distinguish between three related but distinct ideas floating around in the small but vibrant community of alternative OS design: composable user interfaces (which I didn’t coin but popularized), homogeneous operating systems (coined by Eccentric Computing to describe TempleOS), and language-based systems (coined by Fred Schneider but generalized by Lukas Hartmann in his proposal for InterimOS).
A composable user interface is a system where components under control of the user can be combined together. For instance, command line tools in the UNIX command line are composable because they can be combined using pipes (and these compositions can be saved as shell scripts and reused in an automatic way), while a collection of graphical applications in X, although they can be used together by pasting the output of one into another, is not composable because the communication between them requires user input. A modicum of composability can be created in non-composable systems through an automation language (such as AppleScript), but because this is not an integrated part of the interface and a natural extension of normal use (the way pipes are for the command line), this does not make the UI itself composable. A composable UI can be text-based (for instance, practically every programming language has composability, and both bourne shells and the powershell allow for composition of foreign components), or they can be graphical (such as the Alto GUI or HyperNeWS), or they can be console-based (like emacs or TempleOS).
A fully homogenous operating system is an operating system where all layers of interaction operate by the same set of rules: the command shell interprets the same language you use to write device drivers and kernel modules, all hotkeys work in every context, and there are no special domains in which the rules of interaction change. We can look at homogeneity as a scale, however: TempleOS, LISP machines, and the Alto are extremely homogeneous — all running code is in the same language, which can be inspected and modified while it runs; Plan9 is slightly less homogenous, with a handful of realms: C code with resident source for system programs and command line tools, a bourne-style shell that can access all system facilities through an extremely consistent filesystem layer, and a graphical interface that is both internally consistent and integrated with the shell; the UNIX command line is less homogenous, with a separate privileged realm of C programs able to interact directly with APIs that the shell cannot; at the far end of extreme a-homogeneity is the original Mac OS and DOS, where applications are completely unaware of each other and fully incapable of any interaction, and where users cannot write meaningfully complex software with the normal mechanisms by which they interact with their computers but instead must seek out and learn specialized development tools.
It should be clear that a homogeneous operating system has both textual and non-textual components: even a fully command-line-based operating system (let alone a console-based one like TempleOS) has behaviors that, though keyboard-driven, aren’t a programming language proper & have no place in a source file but are nevertheless semantically meaningful to some kind of interpreter, such as line editing and job control. A language-based system is one that, in terms of this source-code-oriented perspective only, is homogeneous: all operations are in terms of well-defined behaviors in some particular language, and there are no special privileged domains beyond this, although there may be restricted domains on top of it.
There are two factors that tie these three ideas together: consistency and power. A composable user interface has the power of a programming language, regardless of its form. A homogeneous operating system has composability by definition, because the language in which system and application software is written must support composition, but its key feature is that the mechanism of this composition is consistent across layers of abstraction. A language-based system has an internally consistent ground level, and all other behavior must be consistent with and no more powerful than this underlying representation.
A fully homogeneous operating system is, then, a language-based system with a top-level user interface that is consistent with (structurally similar and equivalent in power to) the underlying language, and which manipulates the same domain.