The operating system: should there be one?
Presenter: Michael
Preview
I will present a PLOS ’13 paper entitled “The operating system: should there be one?” (yes, that title is officially lowercase), by Stephen Kell of Oracle Labs. To whet your appetite and incite widespread interest, here’s the second sentence: “We revisit Dan Ingalls’ Smalltalk-inspired position that ‘an operating system is a collection of things that don’t fit inside a language; there shouldn’t be one’, discussing what is means, why it appears not to have materialised, and how we might work towards the same effect in the postmodern reality of today’s systems.”
See you there. Michael
Summary
Stephen Kell begins by summarizing Dan Ingall’s vision of Smalltalk from 1981, who said in an issue of Byte magazine (see attachments below) that “an operating system is a collection of things that don’t fit into a language. There shouldn’t be one.” In that article (Design Principles Behind Smalltalk), Dan Ingall expounds philosophically on the nature of human-human and human-computer interaction, asserting that we Smalltalk is more than just a better language – it is all that is needed to support the explicit and implicit interactions between humans and computers. He argues that a system must be comprehensible to a single individual, otherwise it becomes a barrier to creativity, etc, and argues in favors of Smalltalk’s main design principles (objects, automatic storage management, message-passing, and the uniform metaphor).
Kell then proceeds to explain that essentially, Ingall had a vision of reducing software complexity, via Smalltalk alone, by emphasizing that such systems should have: 1. Programmability (consistent view of and language to program all user and system objects) 2. Metasystem (information about all objects, information about that information, etc.) 3. Interposable bindings (communicating messages, object reference flow, etc.)
Then Kell shows how Unix and its derivatives like Plan 9 have facilities that somewhat meet the 3 requirements listed above. A big difference is that Unix only concerns itself with large objects (files) rather than units of data the size of program variables. Therefore, Unix’s obliviousness to diverse implementations of language-level abstractions has caused fragmentation.
Finally, Kell shows ways that we can harness current OS facilities to regain some of the idealized Smalltalk-like capabilities the Ingall argues are imperative we have. Unix, he says, has generic object abstraction and programmability in its shell, compiler, and various DSLs; a metasystem like the /proc filesystem and parseable binary formats; and interposable late bindings in ELF shared libraries and MMU. He ends with an example of how it might be possible to retrofit a more object-oriented interpretation onto grep’s behavior, so that it acquires the ability to search objects like zipped files and mailboxes.
A very interesting side note he makes is that essentially what is required (and what you would be building) is an OS service that allows machine-assisted or fully-automated synthesis of composition-forming code. He references a APSys 2010 paper (DDE: Dynamic Data Structure Excavation) which extracts data structure information from symbol-less binaries (this paper also mentions the CodeSurfer tool).
To conclude, Kell argues that a unified Smalltalk system is unrealistic, but that a system’s role should be to construct meaningful views of the data in our current complex system, and that building a Smalltalk out of today’s systems is possible (albeit difficult). “Far from being replaced by an all-conquering programming langauge, operating systems can and should provide mechanisms that allow languages to come and go which [sic] maximise the composability of the software written using them.”
Discussion
We had a lively discussion about the paper, as well as a short demonstration of Squeak (a Smalltalk implementation).
Our discussion was mostly about the relative merits of having a single language and system controlling a computer. It was agreed that it would be beneficial to have some program-independent object representation, managed by the OS, for being able to pass data between programs written in different languages. That way, one could get the benefits of Smalltalk’s metadata system, available for absolutely all objects in its system, into more realistic systems like Unix and Linux.
Related to this notion of object- and message-passing, we discussed the goal of the .Net framework (having some underlying AST that multiple languages could communicate with); Objective C’s Bonjour protocol, and Miroslav’s message-passing window manager. The latter topic was brought up in defense of not needing an entire language-based OS dominating everything, because diverse message-passing semantics can be replicated in our current environments.
We also pondered on whether an IDE or system has been created that understands the semantics of any language and presents this semantic view to the user, at a level higher than files. We considered briefly the Dylan IDE, but it seems there have been several (failed) attempts at creating semantically-aware IDEs (more than just superficial use of ctags or the things done in Eclipse for Java, etc.). Maybe there’s an interesting direction to go here, or maybe such attempts have failed, or at least never caught on in the past, for good reason.