Composable Interfaces and Interaction

Underlying Architecture

OSes recognize content to an extent but generally lack sufficient standardized methods of interaction in ways that third-party applications do (with the exception of viewing, which works the same everywhere — assuming format is readable) but not for editing or modifying any of it. This is gradually changing however, a good example is Apple's "quick-edit" feature where a system method is provided for modifying video and image content (e.g. cropping and annotation).

We need more system default interfaces for common interactions with digital content — a better host OS would contain a higher-degree of coupling between its native interface for interacting with content and the application layer to standardize common interactions.

3rd party apps should not have full-blown interfaces if they can rely on system ones — a consistent OS level implementation of a common interactions should be leveraged to produce outputs that are beyond what is possible with the native utility — in other words, developers need not build their own interface for something that already exists and works on the host OS. e.g. video editing software would augment the existing system interface with additional features & functionality as a plug-in — unifying the computing interaction experience.

The Medium is the Message

The context where information is presented determines how you can interact with it in terms of actions and associations e.g. remix, share, edit etc. otherwise digital presentation would no different from physical print. It is what defines the realm of possibility. In this sense, the OS is the primary medium, and the application is a function within the OS.

Types of System Interfaces

Fixed Interfaces

Thoughtfully designed consistent interfaces are preferable when operating at the system level — as evident by the persistent title and menu bars across the thematic design of traditional operating systems, these define the aesthetic and its "way of doing things":

For example, some DRY components of a traditional fixed OS interface are:

  • Contextual Menus - menu bars and expanded options (on mobile)
  • Contextual Tools - your typical sidebar
  • Context Definitions – title bars
  • Navigational Scheme - back/forward (vertical interfaces on mobile should be explored more where everything is infinitely nested)
  • Data Organization Scheme - folders on desktop, app silos on mobile (why this is bad)

Mobile OSes usually only retain data in the context of applications, effectively locking you into the application, which is not a problem unique to mobile apps but more along the issue of siloed data.

The fixed interface is essentially the means of navigating across an operating system — applications and information whilst surfacing operations relevant to each. New navigational schemes require new fixed interfaces for representing and interacting with content but probably not a drastic departure from the status quo.

Composable Interfaces

Within the the context of an application in an OS, an interface should be fully composable as it is in most operating systems — UI design. However, what makes an interface composable is being able to accept data as an input and represent it in user-configurable view modes on both the application and OS levels.

  • App UI Design - Pre-composed interface in Application Layer within OS.
  • Composable App UI - user-configurable interface in Application Layer within OS but it is user-composed or easily configurable as a preset template. Configuration includes setting data source and view type.
  • Composable OS UI - Interfaces shouldn't be constrained to the application layer but it should be capable of moving and being represented between applications and outside them similar to the notion of widgets but with 10x versatility.

Composable OS UIs get interesting when considering alternative navigational schemes (spatial, for example) as opposed to hierarchical folder-based navigation, and become especially powerful when combined with fixed interface components that unify the interface structure throughout the OS while presenting contextually relevant interactions. i.e. persisting the fixed interface of the OS throughout and making it reflect functions that can be performed upon the content.